Merge lp:~chipaca/ubuntu-push/the-merge-automatic into lp:ubuntu-push

[John Lenton]

from debian/changelog:

  [ Samuele Pedroni ]
  * Support registering tokens and sending notifications with a token
  * Register script and scripts unicast support
  * Update http13client from the actual go1.3 release
  * Avoid late pings in the face of nop exchanges
  * murmur3 upstream change of seed to 0

  [ Roberto Alsina ]
  * Make signing-helper generate a HTTP header instead of a querystring,
    and take a URL to sign.
  * Wrap libmessaging-menu to allow for persistent notifications.
  * Wrap ubuntu-app-launch start_helper / stop_helper functions.

  [ John R. Lenton ]
  * Switch dbus api to retrieve app name from dbus path.
  * Move signing bits up from session to client, for reuse by service.
  * Change AuthHelper to be a string; auth helper should now expect a
    parameter (the url to sign). Added SessionURL to config.
  * Adapt our whoopsie wrapper to whoopsie's now more correct behavior wrt
    failing to get a mac address.
  * Add registration_url to config; hook up auth bits and reg url to
    client & service.
  * Do an HTTP POST to registration_url on register.
  * Fix debian/rules so packaging-time tests pass (ugh)

  [ Guillermo Gonzalez ]
  * Split DBus service into PushService and PostalService

=== modified file 'Makefile'
--- Makefile	2014-06-02 11:37:03 +0000
+++ Makefile	2014-07-02 13:12:36 +0000
@@ -36,8 +36,8 @@
 	$(GOPATH)/bin/godeps -u dependencies.tsv
 	go install $(GODEPS)
 
-dependencies.tsv: $(TOBUILD)
-	$(GOPATH)/bin/godeps -t $(foreach i,$^,$(dir $(PROJECT)/$(i))) 2>/dev/null | cat > $@
+dependencies.tsv:
+	$(GOPATH)/bin/godeps -t $(TOTEST) $(foreach i,$(TOBUILD),$(dir $(PROJECT)/$(i))) 2>/dev/null | cat > $@
 
 check:
 	go test $(TESTFLAGS) $(TOTEST)
 
=== modified file 'PACKAGE_DEPS'
--- PACKAGE_DEPS	2014-05-23 06:21:46 +0000
+++ PACKAGE_DEPS	2014-07-02 13:12:36 +0000
@@ -8,3 +8,5 @@
 libsqlite3-dev
 libubuntuoneauth-2.0-dev
 libwhoopsie-dev
+libmessaging-menu-dev
+libubuntu-app-launch2-dev
 
=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2014-05-09 10:48:39 +0000
+++ bus/connectivity/connectivity_test.go	2014-07-02 13:12:36 +0000
@@ -160,13 +160,13 @@
 	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 }
-func (*racyEndpoint) GrabName(bool) <-chan error                       { return nil }
-func (*racyEndpoint) WatchMethod(bus.DispatchMap, ...interface{})      {}
-func (*racyEndpoint) Signal(member string, args []interface{}) error   { 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 }
+func (*racyEndpoint) GrabName(bool) <-chan error                                    { return nil }
+func (*racyEndpoint) WatchMethod(bus.DispatchMap, string, ...interface{})           {}
+func (*racyEndpoint) Signal(member string, suffix string, args []interface{}) error { return nil }
 
 var _ bus.Endpoint = (*racyEndpoint)(nil)
 
 
=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-05-15 11:28:06 +0000
+++ bus/endpoint.go	2014-07-02 13:12:36 +0000
@@ -21,7 +21,9 @@
 import (
 	"errors"
 	"fmt"
+
 	"launchpad.net/go-dbus/v1"
+
 	"launchpad.net/ubuntu-push/logger"
 )
 
@@ -29,15 +31,15 @@
  *    Endpoint (and its implementation)
  */
 
-type BusMethod func([]interface{}, []interface{}) ([]interface{}, error)
+type BusMethod func(string, []interface{}, []interface{}) ([]interface{}, error)
 type DispatchMap map[string]BusMethod
 
 // bus.Endpoint represents the DBus connection itself.
 type Endpoint interface {
 	GrabName(allowReplacement bool) <-chan error
 	WatchSignal(member string, f func(...interface{}), d func()) error
-	WatchMethod(DispatchMap, ...interface{})
-	Signal(string, []interface{}) error
+	WatchMethod(DispatchMap, string, ...interface{})
+	Signal(string, string, []interface{}) error
 	Call(member string, args []interface{}, rvs ...interface{}) error
 	GetProperty(property string) (interface{}, error)
 	Dial() error
@@ -212,8 +214,9 @@
 // Signal() sends out a signal called <member> containing <args>.
 //
 // XXX: untested
-func (endp *endpoint) Signal(member string, args []interface{}) error {
-	msg := dbus.NewSignalMessage(dbus.ObjectPath(endp.addr.Path), endp.addr.Interface, member)
+func (endp *endpoint) Signal(member string, suffix string, args []interface{}) error {
+	path := dbus.ObjectPath(endp.addr.Path + suffix)
+	msg := dbus.NewSignalMessage(path, endp.addr.Interface, member)
 	if args != nil {
 		err := msg.AppendArgs(args...)
 		if err != nil {
@@ -234,7 +237,7 @@
 // calls.
 //
 // XXX: untested
-func (endp *endpoint) WatchMethod(dispatch DispatchMap, extra ...interface{}) {
+func (endp *endpoint) WatchMethod(dispatch DispatchMap, suffix string, extra ...interface{}) {
 	ch := make(chan *dbus.Message)
 	go func() {
 		var reply *dbus.Message
@@ -249,12 +252,12 @@
 				endp.log.Errorf("WatchMethod: unknown method %s", msg.Member)
 			} else {
 				args := msg.AllArgs()
-				rvals, err := meth(args, extra)
+				rvals, err := meth(string(msg.Path), args, extra)
 				if err != nil {
 					reply = dbus.NewErrorMessage(msg, err_iface, err.Error())
-					endp.log.Errorf("WatchMethod: %s(%#v, %#v) failure: %#v", msg.Member, args, extra, err)
+					endp.log.Errorf("WatchMethod: %s(%v, %#v, %#v) failure: %#v", msg.Member, msg.Path, args, extra, err)
 				} else {
-					endp.log.Debugf("WatchMethod: %s(%#v, %#v) success: %#v", msg.Member, args, extra, rvals)
+					endp.log.Debugf("WatchMethod: %s(%v, %#v, %#v) success: %#v", msg.Member, msg.Path, args, extra, rvals)
 					reply = dbus.NewMethodReturnMessage(msg)
 					err = reply.AppendArgs(rvals...)
 					if err != nil {
@@ -270,7 +273,8 @@
 
 		}
 	}()
-	endp.bus.RegisterObjectPath(dbus.ObjectPath(endp.addr.Path), ch)
+	path := dbus.ObjectPath(endp.addr.Path + suffix)
+	endp.bus.RegisterObjectPath(path, ch)
 }
 
 /*
 
=== added directory 'bus/notifications/app_helper'
=== added file 'bus/notifications/app_helper/app_helper_c.go'
--- bus/notifications/app_helper/app_helper_c.go	1970-01-01 00:00:00 +0000
+++ bus/notifications/app_helper/app_helper_c.go	2014-07-02 13:12:36 +0000
@@ -0,0 +1,41 @@
+/*
+ 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 app_helper wraps C functions to access app information
+package app_helper
+
+/*
+#cgo pkg-config: gio-unix-2.0
+#cgo pkg-config: gio-2.0
+#include <stdlib.h>
+#include <glib.h>
+#include <gio/gdesktopappinfo.h>
+*/
+import "C"
+import "unsafe"
+
+func AppIconFromId(appId string) string {
+	_id := C.CString(appId)
+	defer C.free(unsafe.Pointer(_id))
+	_app_info := C.g_desktop_app_info_new(_id)
+	defer C.g_app_info_delete(_app_info)
+	_app_icon := C.g_app_info_get_icon(_app_info)
+	defer C.g_object_unref((C.gpointer)(_app_icon))
+	_icon_string := C.g_icon_to_string(_app_icon)
+	defer C.free(unsafe.Pointer(_icon_string))
+	name := C.GoString((*C.char)(_icon_string))
+	return name
+}
 
=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2014-05-20 10:50:04 +0000
+++ bus/notifications/raw.go	2014-07-02 13:12:36 +0000
@@ -23,9 +23,12 @@
 
 import (
 	"errors"
+	"fmt"
 
 	"launchpad.net/go-dbus/v1"
 	"launchpad.net/ubuntu-push/bus"
+	c_helper "launchpad.net/ubuntu-push/bus/notifications/app_helper"
+	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 )
 
@@ -96,3 +99,36 @@
 	}
 	return ch, nil
 }
+
+// ShowCard displays a given card.
+//
+// If card.Actions has 1 action, it's an interactive notification.
+// If card.Actions has 2 or more actions, it will show as a snap decision.
+//
+// WatchActions will receive something like this in the ActionId field:
+// appId::notificationId::action.Id
+func (raw *RawNotifications) Present(appId string, notificationId string, notification *launch_helper.Notification) (uint32, error) {
+	if notification == nil || notification.Card == nil || !notification.Card.Popup || notification.Card.Summary == "" {
+		raw.log.Debugf("skipping notification: nil, or nil card, or not popup, or no summary: %#v", notification)
+		return 0, nil
+	}
+
+	card := notification.Card
+
+	app_icon := c_helper.AppIconFromId(appId)
+	hints := make(map[string]*dbus.Variant)
+	hints["x-canonical-secondary-icon"] = &dbus.Variant{app_icon}
+
+	actions := make([]string, 2*len(card.Actions))
+	for i, action := range card.Actions {
+		actions[2*i] = fmt.Sprintf("%s::%s::%d", appId, notificationId, i)
+		actions[2*i+1] = action
+	}
+	switch len(actions) {
+	case 2:
+		hints["x-canonical-switch-to-application"] = &dbus.Variant{true}
+	case 4:
+		hints["x-canonical-snap-decisions"] = &dbus.Variant{true}
+	}
+	return raw.Notify(appId, 0, card.Icon, card.Summary, card.Body, actions, hints, 30*1000)
+}
 
=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-05-20 10:50:04 +0000
+++ bus/notifications/raw_test.go	2014-07-02 13:12:36 +0000
@@ -22,6 +22,7 @@
 import (
 	. "launchpad.net/gocheck"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
@@ -95,3 +96,45 @@
 	_, err := raw.WatchActions()
 	c.Check(err, NotNil)
 }
+
+func (s *RawSuite) TestPresentNotifies(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
+	c.Check(err, IsNil)
+	c.Check(nid, Equals, uint32(1))
+}
+
+func (s *RawSuite) TestPresentNoNotificationDoesNotNotify(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	nid, err := raw.Present("firefox.desktop", "notifId", nil)
+	c.Check(err, IsNil)
+	c.Check(nid, Equals, uint32(0))
+}
+
+func (s *RawSuite) TestPresentNoCardDoesNotNotify(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{})
+	c.Check(err, IsNil)
+	c.Check(nid, Equals, uint32(0))
+}
+
+func (s *RawSuite) TestPresentNoSummaryDoesNotNotify(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{Card: &launch_helper.Card{}})
+	c.Check(err, IsNil)
+	c.Check(nid, Equals, uint32(0))
+}
+
+func (s *RawSuite) TestPresentNoPopupNoNotify(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary"}})
+	c.Check(err, IsNil)
+	c.Check(nid, Equals, uint32(0))
+}
+
+// XXX Missing test about ShowCard manipulating Actions and hints correctly.
 
=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-05-15 12:27:32 +0000
+++ bus/testing/testing_endpoint.go	2014-07-02 13:12:36 +0000
@@ -187,7 +187,7 @@
 	return nil
 }
 
-func (tc *testingEndpoint) WatchMethod(dispatch bus.DispatchMap, extra ...interface{}) {
+func (tc *testingEndpoint) WatchMethod(dispatch bus.DispatchMap, suffix string, extra ...interface{}) {
 	tc.callArgsLck.Lock()
 	defer tc.callArgsLck.Unlock()
 
@@ -196,12 +196,12 @@
 	tc.callArgs = append(tc.callArgs, args)
 }
 
-func (tc *testingEndpoint) Signal(member string, args []interface{}) error {
+func (tc *testingEndpoint) Signal(member string, suffix string, args []interface{}) error {
 	tc.callArgsLck.Lock()
 	defer tc.callArgsLck.Unlock()
 
 	callargs := callArgs{Member: "::Signal"}
-	callargs.Args = append(callargs.Args, member, args)
+	callargs.Args = append(callargs.Args, member, suffix, args)
 	tc.callArgs = append(tc.callArgs, callargs)
 
 	return nil
 
=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-06-02 10:04:34 +0000
+++ bus/testing/testing_endpoint_test.go	2014-07-02 13:12:36 +0000
@@ -214,24 +214,24 @@
 // Test that Signal updates callArgs
 func (s *TestingEndpointSuite) TestSignalUpdatesCallArgs(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(true))
-	endp.Signal("hello", []interface{}{"world"})
-	endp.Signal("hello", []interface{}{"there"})
+	endp.Signal("hello", "", []interface{}{"world"})
+	endp.Signal("hello", "/potato", []interface{}{"there"})
 	c.Check(GetCallArgs(endp), DeepEquals, []callArgs{
 		{
 			Member: "::Signal",
-			Args:   []interface{}{"hello", []interface{}{"world"}},
+			Args:   []interface{}{"hello", "", []interface{}{"world"}},
 		}, {
 			Member: "::Signal",
-			Args:   []interface{}{"hello", []interface{}{"there"}},
+			Args:   []interface{}{"hello", "/potato", []interface{}{"there"}},
 		}})
 }
 
 // Test that WatchMethod updates callArgs
 func (s *TestingEndpointSuite) TestWatchMethodUpdatesCallArgs(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(true))
-	foo := func([]interface{}, []interface{}) ([]interface{}, error) { return nil, nil }
+	foo := func(string, []interface{}, []interface{}) ([]interface{}, error) { return nil, nil }
 	foomp := bus.DispatchMap{"foo": foo}
-	endp.WatchMethod(foomp)
+	endp.WatchMethod(foomp, "/*")
 	c.Check(GetCallArgs(endp), DeepEquals, []callArgs{
 		{
 			Member: "::WatchMethod",
 
=== modified file 'client/client.go'
--- client/client.go	2014-05-21 10:03:18 +0000
+++ client/client.go	2014-07-02 13:12:36 +0000
@@ -22,16 +22,14 @@
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/hex"
-	"encoding/json"
 	"encoding/pem"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
+	"os/exec"
 	"strings"
 
-	"launchpad.net/go-dbus/v1"
-
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/connectivity"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
@@ -63,40 +61,38 @@
 	// The PEM-encoded server certificate
 	CertPEMFile string `json:"cert_pem_file"`
 	// How to invoke the auth helper
-	AuthHelper []string `json:"auth_helper"`
+	AuthHelper      string `json:"auth_helper"`
+	SessionURL      string `json:"session_url"`
+	RegistrationURL string `json:"registration_url"`
 	// The logging level (one of "debug", "info", "error")
 	LogLevel logger.ConfigLogLevel `json:"log_level"`
 }
 
 // PushClient is the Ubuntu Push Notifications client-side daemon.
 type PushClient struct {
-	leveldbPath        string
-	configPath         string
-	config             ClientConfig
-	log                logger.Logger
-	pem                []byte
-	idder              identifier.Id
-	deviceId           string
-	notificationsEndp  bus.Endpoint
-	urlDispatcherEndp  bus.Endpoint
-	connectivityEndp   bus.Endpoint
-	systemImageEndp    bus.Endpoint
-	systemImageInfo    *systemimage.InfoResult
-	connCh             chan bool
-	hasConnectivity    bool
-	actionsCh          <-chan notifications.RawActionReply
-	session            *session.ClientSession
-	sessionConnectedCh chan uint32
-	serviceEndpoint    bus.Endpoint
-	service            *service.Service
+	leveldbPath           string
+	configPath            string
+	config                ClientConfig
+	log                   logger.Logger
+	pem                   []byte
+	idder                 identifier.Id
+	deviceId              string
+	notificationsEndp     bus.Endpoint
+	urlDispatcherEndp     bus.Endpoint
+	connectivityEndp      bus.Endpoint
+	systemImageEndp       bus.Endpoint
+	systemImageInfo       *systemimage.InfoResult
+	connCh                chan bool
+	hasConnectivity       bool
+	actionsCh             <-chan notifications.RawActionReply
+	session               *session.ClientSession
+	sessionConnectedCh    chan uint32
+	pushServiceEndpoint   bus.Endpoint
+	pushService           *service.PushService
+	postalServiceEndpoint bus.Endpoint
+	postalService         *service.PostalService
 }
 
-var (
-	system_update_url   = "settings:///system/system-update"
-	ACTION_ID_SNOWFLAKE = "::ubuntu-push-client::"
-	ACTION_ID_BROADCAST = ACTION_ID_SNOWFLAKE + system_update_url
-)
-
 // Creates a new Ubuntu Push Notifications client-side daemon that will use
 // the given configuration file.
 func NewPushClient(configPath string, leveldbPath string) *PushClient {
@@ -128,10 +124,12 @@
 
 	// overridden for testing
 	client.idder = identifier.New()
-	client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
 	client.urlDispatcherEndp = bus.SessionBus.Endpoint(urldispatcher.BusAddress, client.log)
 	client.connectivityEndp = bus.SystemBus.Endpoint(networkmanager.BusAddress, client.log)
 	client.systemImageEndp = bus.SystemBus.Endpoint(systemimage.BusAddress, client.log)
+	if client.notificationsEndp == nil {
+		client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
+	}
 
 	client.connCh = make(chan bool, 1)
 	client.sessionConnectedCh = make(chan uint32, 1)
@@ -160,7 +158,27 @@
 		ExpectAllRepairedTime:  client.config.ExpectAllRepairedTime.TimeDuration(),
 		PEM:        client.pem,
 		Info:       info,
-		AuthHelper: client.config.AuthHelper,
+		AuthGetter: client.getAuthorization,
+		AuthURL:    client.config.SessionURL,
+	}
+}
+
+// getAuthorization gets the authorization blob to send to the server
+func (client *PushClient) getAuthorization(url string) string {
+	client.log.Debugf("getting authorization for %s", url)
+	// using a helper, for now at least
+	if len(client.config.AuthHelper) == 0 {
+		// do nothing if helper is unset or empty
+		return ""
+	}
+
+	auth, err := exec.Command(client.config.AuthHelper, url).Output()
+	if err != nil {
+		// For now we just log the error, as we don't want to block unauthorized users
+		client.log.Errorf("unable to get the authorization token from the account: %v", err)
+		return ""
+	} else {
+		return strings.TrimSpace(string(auth))
 	}
 }
 
@@ -185,12 +203,10 @@
 	go connectivity.ConnectedState(client.connectivityEndp,
 		client.config.ConnectivityConfig, client.log, client.connCh)
 	iniCh := make(chan uint32)
-	go func() { iniCh <- util.NewAutoRedialer(client.notificationsEndp).Redial() }()
 	go func() { iniCh <- util.NewAutoRedialer(client.urlDispatcherEndp).Redial() }()
 	go func() { iniCh <- util.NewAutoRedialer(client.systemImageEndp).Redial() }()
 	<-iniCh
 	<-iniCh
-	<-iniCh
 
 	sysimg := systemimage.New(client.systemImageEndp, client.log)
 	info, err := sysimg.Info()
@@ -198,8 +214,11 @@
 		return err
 	}
 	client.systemImageInfo = info
+	return err
+}
 
-	actionsCh, err := notifications.Raw(client.notificationsEndp, client.log).WatchActions()
+func (client *PushClient) takePostalServiceBus() error {
+	actionsCh, err := client.postalService.TakeTheBus()
 	client.actionsCh = actionsCh
 	return err
 }
@@ -296,28 +315,12 @@
 	return false
 }
 
-func (client *PushClient) sendNotification(action_id, icon, summary, body string) (uint32, error) {
-	a := []string{action_id, "Switch to app"} // action value not visible on the phone
-	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
-	nots := notifications.Raw(client.notificationsEndp, client.log)
-	return nots.Notify(
-		"ubuntu-push-client", // app name
-		uint32(0),            // id
-		icon,                 // icon
-		summary,              // summary
-		body,                 // body
-		a,                    // actions
-		h,                    // hints
-		int32(10*1000),       // timeout (ms)
-	)
-}
-
 // handleBroadcastNotification deals with receiving a broadcast notification
 func (client *PushClient) handleBroadcastNotification(msg *session.BroadcastNotification) error {
 	if !client.filterBroadcastNotification(msg) {
 		return nil
 	}
-	not_id, err := client.sendNotification(ACTION_ID_BROADCAST,
+	not_id, err := client.postalService.SendNotification(service.ACTION_ID_BROADCAST,
 		"update_manager_icon", "There's an updated system image.",
 		"Tap to open the system updater.")
 	if err != nil {
@@ -331,7 +334,7 @@
 // handleUnicastNotification deals with receiving a unicast notification
 func (client *PushClient) handleUnicastNotification(msg *protocol.Notification) error {
 	client.log.Debugf("sending notification %#v for %#v.", msg.MsgId, msg.AppId)
-	return client.service.Inject(msg.AppId, string(msg.Payload))
+	return client.postalService.Inject(msg.AppId, msg.MsgId, string(msg.Payload))
 }
 
 // handleClick deals with the user clicking a notification
@@ -342,7 +345,7 @@
 	//
 	// From ACM's SIGPLAN publication, (September, 1982), Article
 	// "Epigrams in Programming", by Alan J. Perlis of Yale University.
-	url := strings.TrimPrefix(action_id, ACTION_ID_SNOWFLAKE)
+	url := strings.TrimPrefix(action_id, service.ACTION_ID_SNOWFLAKE)
 	if len(url) == len(action_id) || len(url) == 0 {
 		// it didn't start with the prefix
 		return nil
@@ -392,52 +395,49 @@
 		client.handleErr)
 }
 
-// these are the currently supported fields of a unicast message
-type UnicastMessage struct {
-	Icon    string          `json:"icon"`
-	Body    string          `json:"body"`
-	Summary string          `json:"summary"`
-	URL     string          `json:"url"`
-	Blob    json.RawMessage `json:"blob"`
-}
-
-func (client *PushClient) messageHandler(message []byte) error {
-	var umsg = new(UnicastMessage)
-	err := json.Unmarshal(message, &umsg)
-	if err != nil {
-		client.log.Errorf("unable to unmarshal message: %v", err)
-		return err
-	}
-
-	not_id, err := client.sendNotification(
-		ACTION_ID_SNOWFLAKE+umsg.URL,
-		umsg.Icon, umsg.Summary, umsg.Body)
-
-	if err != nil {
-		client.log.Errorf("showing notification: %s", err)
-		return err
-	}
-	client.log.Debugf("got notification id %d", not_id)
-	return nil
-}
-
 func (client *PushClient) startService() error {
-	if client.serviceEndpoint == nil {
-		client.serviceEndpoint = bus.SessionBus.Endpoint(service.BusAddress, client.log)
-	}
-
-	client.service = service.NewService(client.serviceEndpoint, client.log)
-	client.service.SetMessageHandler(client.messageHandler)
-	return client.service.Start()
+	if client.pushServiceEndpoint == nil {
+		client.pushServiceEndpoint = bus.SessionBus.Endpoint(service.PushServiceBusAddress, client.log)
+	}
+	if client.postalServiceEndpoint == nil {
+		client.postalServiceEndpoint = bus.SessionBus.Endpoint(service.PostalServiceBusAddress, client.log)
+	}
+
+	client.pushService = service.NewPushService(client.pushServiceEndpoint, client.log)
+	client.pushService.SetRegistrationURL(client.config.RegistrationURL)
+	client.pushService.SetAuthGetter(client.getAuthorization)
+	client.pushService.SetDeviceId(client.deviceId)
+	if err := client.pushService.Start(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (client *PushClient) setupPostalService() error {
+	if client.notificationsEndp == nil {
+		client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
+	}
+	client.postalService = service.NewPostalService(client.postalServiceEndpoint, client.notificationsEndp, client.log)
+	return nil
+}
+
+func (client *PushClient) startPostalService() error {
+	if err := client.postalService.Start(); err != nil {
+		return err
+	}
+	return nil
 }
 
 // Start calls doStart with the "real" starters
 func (client *PushClient) Start() error {
 	return client.doStart(
 		client.configure,
+		client.getDeviceId,
 		client.startService,
-		client.getDeviceId,
+		client.setupPostalService,
+		client.startPostalService,
 		client.takeTheBus,
+		client.takePostalServiceBus,
 		client.initSession,
 	)
 }
 
=== modified file 'client/client_test.go'
--- client/client_test.go	2014-05-20 13:56:37 +0000
+++ client/client_test.go	2014-07-02 13:12:36 +0000
@@ -37,6 +37,7 @@
 	"launchpad.net/ubuntu-push/bus/notifications"
 	"launchpad.net/ubuntu-push/bus/systemimage"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/client/service"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/seenstate"
 	"launchpad.net/ubuntu-push/config"
@@ -103,11 +104,13 @@
 		"stabilizing_timeout":    "0ms",
 		"connectivity_check_url": "",
 		"connectivity_check_md5": "",
-		"addr":            ":0",
-		"cert_pem_file":   pem_file,
-		"recheck_timeout": "3h",
-		"auth_helper":     []string{},
-		"log_level":       "debug",
+		"addr":             ":0",
+		"cert_pem_file":    pem_file,
+		"recheck_timeout":  "3h",
+		"auth_helper":      "",
+		"session_url":      "xyzzy://",
+		"registration_url": "reg://",
+		"log_level":        "debug",
 	}
 	for k, v := range overrides {
 		cfgMap[k] = v
@@ -257,7 +260,7 @@
 
 func (cs *clientSuite) TestDeriveSessionConfig(c *C) {
 	cs.writeTestConfig(map[string]interface{}{
-		"auth_helper": []string{"auth", "helper"},
+		"auth_helper": "auth helper",
 	})
 	info := map[string]interface{}{
 		"foo": 1,
@@ -272,7 +275,8 @@
 		ExpectAllRepairedTime:  30 * time.Minute,
 		PEM:        cli.pem,
 		Info:       info,
-		AuthHelper: []string{"auth", "helper"},
+		AuthGetter: func(string) string { return "" },
+		AuthURL:    "xyzzy://",
 	}
 	// sanity check that we are looking at all fields
 	vExpected := reflect.ValueOf(expected)
@@ -284,6 +288,11 @@
 	}
 	// finally compare
 	conf := cli.deriveSessionConfig(info)
+	// compare authGetter by string
+	c.Check(fmt.Sprintf("%v", conf.AuthGetter), Equals, fmt.Sprintf("%v", cli.getAuthorization))
+	// and set it to nil
+	conf.AuthGetter = nil
+	expected.AuthGetter = nil
 	c.Check(conf, DeepEquals, expected)
 }
 
@@ -292,28 +301,54 @@
 ******************************************************************/
 
 func (cs *clientSuite) TestStartServiceWorks(c *C) {
+	cs.writeTestConfig(map[string]interface{}{
+		"auth_helper": helpers.ScriptAbsPath("dummyauth.sh"),
+	})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.configure()
 	cli.log = cs.log
-	cli.serviceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
-	c.Check(cli.service, IsNil)
+	cli.deviceId = "fake-id"
+	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	c.Check(cli.pushService, IsNil)
 	c.Check(cli.startService(), IsNil)
-	c.Assert(cli.service, NotNil)
-	c.Check(cli.service.IsRunning(), Equals, true)
-	c.Check(cli.service.GetMessageHandler(), NotNil)
-	cli.service.Stop()
+	c.Assert(cli.pushService, NotNil)
+	c.Check(cli.pushService.IsRunning(), Equals, true)
+	c.Check(cli.pushService.GetDeviceId(), Equals, "fake-id")
+	c.Check(cli.pushService.GetRegistrationAuthorization(), Equals, "hello reg://")
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.startPostalService(), IsNil)
+	c.Check(cli.postalService.IsRunning(), Equals, true)
+	cli.pushService.Stop()
+	cli.postalService.Stop()
 }
 
 func (cs *clientSuite) TestStartServiceErrorsOnNilLog(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	c.Check(cli.log, IsNil)
 	c.Check(cli.startService(), NotNil)
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.startPostalService(), NotNil)
 }
 
-func (cs *clientSuite) TestStartServiceErrorsOnBusDialFail(c *C) {
+func (cs *clientSuite) TestStartServiceErrorsOnBusDialPushFail(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
-	cli.serviceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
+	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
 	c.Check(cli.startService(), NotNil)
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.startPostalService(), NotNil)
+}
+
+func (cs *clientSuite) TestStartServiceErrorsOnBusDialPostalFail(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
+	c.Check(cli.startService(), IsNil)
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.startPostalService(), NotNil)
 }
 
 /*****************************************************************
@@ -386,6 +421,8 @@
 	cli.systemImageEndp = siEndp
 
 	c.Assert(cli.takeTheBus(), IsNil)
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.takePostalServiceBus(), IsNil)
 	// the notifications and urldispatcher endpoints retried until connected
 	c.Check(nCond.OK(), Equals, true)
 	c.Check(uCond.OK(), Equals, true)
@@ -415,6 +452,8 @@
 	cli.systemImageEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 
 	c.Check(cli.takeTheBus(), NotNil)
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.takePostalServiceBus(), NotNil)
 	c.Check(cli.actionsCh, IsNil)
 }
 
@@ -608,6 +647,8 @@
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	cli.notificationsEndp = endp
 	cli.log = cs.log
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	cli.setupPostalService()
 	c.Check(cli.handleBroadcastNotification(positiveBroadcastNotification), IsNil)
 	// check we sent the notification
 	args := testibus.GetCallArgs(endp)
@@ -635,6 +676,8 @@
 	cli.log = cs.log
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	cli.notificationsEndp = endp
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	cli.setupPostalService()
 	c.Check(cli.handleBroadcastNotification(positiveBroadcastNotification), NotNil)
 }
 
@@ -642,19 +685,24 @@
     handleUnicastNotification tests
 ******************************************************************/
 
-var notif = &protocol.Notification{AppId: "hello", Payload: []byte(`{"url": "xyzzy"}`), MsgId: "42"}
+var payload = `{"message": "aGVsbG8=", "notification": {"card": {"icon": "icon-value", "summary": "summary-value", "body": "body-value", "actions": []}}}`
+var notif = &protocol.Notification{AppId: "hello", Payload: []byte(payload), MsgId: "42"}
 
 func (cs *clientSuite) TestHandleUcastNotification(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	svcEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
+	postEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
 	cli.log = cs.log
-	cli.serviceEndpoint = svcEndp
+	cli.pushServiceEndpoint = svcEndp
+	cli.postalServiceEndpoint = postEndp
 	notsEndp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	cli.notificationsEndp = notsEndp
 	c.Assert(cli.startService(), IsNil)
+	c.Assert(cli.setupPostalService(), IsNil)
+	c.Assert(cli.startPostalService(), IsNil)
 	c.Check(cli.handleUnicastNotification(notif), IsNil)
 	// check we sent the notification
-	args := testibus.GetCallArgs(svcEndp)
+	args := testibus.GetCallArgs(postEndp)
 	c.Assert(len(args), Not(Equals), 0)
 	c.Check(args[len(args)-1].Member, Equals, "::Signal")
 	c.Check(cs.log.Captured(), Matches, `(?m).*sending notification "42" for "hello".*`)
@@ -675,14 +723,14 @@
 	args := testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 0)
 	// check we worked with the right action id
-	c.Check(cli.handleClick(ACTION_ID_BROADCAST), IsNil)
+	c.Check(cli.handleClick(service.ACTION_ID_BROADCAST), IsNil)
 	// check we sent the notification
 	args = testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 1)
 	c.Check(args[0].Member, Equals, "DispatchURL")
-	c.Check(args[0].Args, DeepEquals, []interface{}{system_update_url})
+	c.Check(args[0].Args, DeepEquals, []interface{}{service.SystemUpdateUrl})
 	// check we worked with the right action id
-	c.Check(cli.handleClick(ACTION_ID_SNOWFLAKE+"foo"), IsNil)
+	c.Check(cli.handleClick(service.ACTION_ID_SNOWFLAKE+"foo"), IsNil)
 	// check we sent the notification
 	args = testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 2)
@@ -810,6 +858,8 @@
 	cli.connectivityEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal))
 	cli.systemImageInfo = siInfoRes
+	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
+	cli.setupPostalService()
 	c.Assert(cli.initSession(), IsNil)
 
 	cli.session.BroadcastCh = make(chan *session.BroadcastNotification)
@@ -829,7 +879,7 @@
 	c.Check(cs.log.Captured(), Matches, "(?ms).*Session connected after 42 attempts$")
 
 	//  * actionsCh to the click handler/url dispatcher
-	aCh <- notifications.RawActionReply{ActionId: ACTION_ID_BROADCAST}
+	aCh <- notifications.RawActionReply{ActionId: service.ACTION_ID_BROADCAST}
 	tick()
 	uargs := testibus.GetCallArgs(cli.urlDispatcherEndp)
 	c.Assert(uargs, HasLen, 1)
@@ -879,7 +929,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	// before start, everything sucks:
 	// no service,
-	c.Check(cli.service, IsNil)
+	c.Check(cli.pushService, IsNil)
 	// no config,
 	c.Check(string(cli.config.Addr), Equals, "")
 	// no device id,
@@ -904,9 +954,10 @@
 	// and a bus,
 	c.Check(cli.notificationsEndp, NotNil)
 	// and a service,
-	c.Check(cli.service, NotNil)
+	c.Check(cli.pushService, NotNil)
 	// and everthying us just peachy!
-	cli.service.Stop() // cleanup
+	cli.pushService.Stop()   // cleanup
+	cli.postalService.Stop() // cleanup
 }
 
 func (cs *clientSuite) TestStartCanFail(c *C) {
@@ -917,37 +968,41 @@
 	c.Check(err, NotNil)
 }
 
-func (cs *clientSuite) TestMessageHandler(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	cli.notificationsEndp = endp
-	cli.log = cs.log
-	err := cli.messageHandler([]byte(`{"icon": "icon-value", "summary": "summary-value", "body": "body-value"}`))
-	c.Assert(err, IsNil)
-	args := testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 1)
-	c.Check(args[0].Member, Equals, "Notify")
-	c.Check(args[0].Args[0], Equals, "ubuntu-push-client")
-	c.Check(args[0].Args[2], Equals, "icon-value")
-	c.Check(args[0].Args[3], Equals, "summary-value")
-	c.Check(args[0].Args[4], Equals, "body-value")
-}
-
-func (cs *clientSuite) TestMessageHandlerReportsUnmarshalErrors(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-
-	err := cli.messageHandler([]byte(`{"broken`))
-	c.Check(err, NotNil)
-	c.Check(cs.log.Captured(), Matches, "(?msi).*unable to unmarshal message:.*")
-}
-
-func (cs *clientSuite) TestMessageHandlerReportsFailedNotifies(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
-	cli.notificationsEndp = endp
-	cli.log = cs.log
-	err := cli.messageHandler([]byte(`{}`))
-	c.Assert(err, NotNil)
-	c.Check(cs.log.Captured(), Matches, "(?msi).*showing notification: no way$")
+func (cs *clientSuite) TestInitSessionErr(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
+	// change the cli.pem value so initSession fails
+	cli.pem = []byte("foo")
+	c.Assert(cli.initSession(), NotNil)
+}
+
+/*****************************************************************
+    getAuthorization() tests
+******************************************************************/
+
+func (cs *clientSuite) TestGetAuthorizationIgnoresErrors(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.configure()
+	cli.config.AuthHelper = "/no/such/executable"
+
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "")
+}
+
+func (cs *clientSuite) TestGetAuthorizationGetsIt(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.configure()
+	cli.config.AuthHelper = helpers.ScriptAbsPath("dummyauth.sh")
+
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "hello xyzzy://")
+}
+
+func (cs *clientSuite) TestGetAuthorizationWorksIfUnsetOrNil(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+
+	c.Assert(cli.config, NotNil)
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "")
+	cli.configure()
+	c.Check(cli.getAuthorization("xyzzy://"), Equals, "")
 }
 
=== modified file 'client/gethosts/gethost_test.go'
--- client/gethosts/gethost_test.go	2014-05-02 10:42:16 +0000
+++ client/gethosts/gethost_test.go	2014-07-02 13:12:36 +0000
@@ -59,7 +59,7 @@
 	res, err := gh.Get()
 	c.Assert(err, IsNil)
 	c.Check(*res, DeepEquals,
-		Host{Domain: "example.com", Hosts: []string{"http://c1130408a700afe0"}})
+		Host{Domain: "example.com", Hosts: []string{"http://bdd2ae7116c85a45"}})
 }
 
 func (s *getHostsSuite) TestGetTimeout(c *C) {
 
=== added file 'client/service/common.go'
--- client/service/common.go	1970-01-01 00:00:00 +0000
+++ client/service/common.go	2014-07-02 13:12:36 +0000
@@ -0,0 +1,99 @@
+/*
+ Copyright 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 service implements the dbus-level service with which client
+// applications are expected to interact.
+package service
+
+import (
+	"errors"
+	"sync"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+type DBusService struct {
+	lock  sync.RWMutex
+	state ServiceState
+	Log   logger.Logger
+	Bus   bus.Endpoint
+}
+
+// the service can be in a numnber of states
+type ServiceState uint8
+
+const (
+	StateUnknown  ServiceState = iota
+	StateRunning               // Start() has been successfully called
+	StateFinished              // Stop() has been successfully called
+)
+
+var (
+	NotConfigured  = errors.New("not configured")
+	AlreadyStarted = errors.New("already started")
+	BadArgCount    = errors.New("Wrong number of arguments")
+	BadArgType     = errors.New("Bad argument type")
+)
+
+// IsRunning() returns whether the service's state is StateRunning
+func (svc *DBusService) IsRunning() bool {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.state == StateRunning
+}
+
+// Start() dials the bus, grab the name, and listens for method calls.
+func (svc *DBusService) Start(dispatchMap bus.DispatchMap, busAddr bus.Address) error {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	if svc.state != StateUnknown {
+		return AlreadyStarted
+	}
+	if svc.Log == nil || svc.Bus == nil {
+		return NotConfigured
+	}
+	err := svc.Bus.Dial()
+	if err != nil {
+		return err
+	}
+	ch := svc.Bus.GrabName(true)
+	log := svc.Log
+	go func() {
+		for err := range ch {
+			if !svc.IsRunning() {
+				break
+			}
+			if err != nil {
+				log.Fatalf("name channel for %s got: %v",
+					busAddr.Name, err)
+			}
+		}
+	}()
+	svc.Bus.WatchMethod(dispatchMap, "/*", svc)
+	svc.state = StateRunning
+	return nil
+}
+
+// Stop() closes the bus and sets the state to StateFinished
+func (svc *DBusService) Stop() {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	if svc.Bus != nil {
+		svc.Bus.Close()
+	}
+	svc.state = StateFinished
+}
 
=== added file 'client/service/postal.go'
--- client/service/postal.go	1970-01-01 00:00:00 +0000
+++ client/service/postal.go	2014-07-02 13:12:36 +0000
@@ -0,0 +1,181 @@
+/*
+ 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 service
+
+import (
+	"strings"
+
+	"code.google.com/p/go-uuid/uuid"
+	"launchpad.net/go-dbus/v1"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/notifications"
+	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/messaging"
+	"launchpad.net/ubuntu-push/nih"
+	"launchpad.net/ubuntu-push/util"
+)
+
+// PostalService is the dbus api
+type PostalService struct {
+	DBusService
+	mbox              map[string][]string
+	msgHandler        func(string, string, *launch_helper.HelperOutput) error
+	HelperLauncher    launch_helper.HelperLauncher
+	messagingMenu     *messaging.MessagingMenu
+	notificationsEndp bus.Endpoint
+}
+
+var (
+	PostalServiceBusAddress = bus.Address{
+		Interface: "com.ubuntu.Postal",
+		Path:      "/com/ubuntu/Postal",
+		Name:      "com.ubuntu.Postal",
+	}
+)
+
+var (
+	SystemUpdateUrl     = "settings:///system/system-update"
+	ACTION_ID_SNOWFLAKE = "::ubuntu-push-client::"
+	ACTION_ID_BROADCAST = ACTION_ID_SNOWFLAKE + SystemUpdateUrl
+)
+
+// NewPostalService() builds a new service and returns it.
+func NewPostalService(busEndp bus.Endpoint, notificationsEndp bus.Endpoint, log logger.Logger) *PostalService {
+	var svc = &PostalService{}
+	svc.Log = log
+	svc.Bus = busEndp
+	svc.messagingMenu = messaging.New(log)
+	svc.HelperLauncher = launch_helper.NewTrivialHelperLauncher(log)
+	svc.notificationsEndp = notificationsEndp
+	svc.msgHandler = svc.messageHandler
+	return svc
+}
+
+// SetMessageHandler() sets the message-handling callback
+func (svc *PostalService) SetMessageHandler(callback func(string, string, *launch_helper.HelperOutput) error) {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	svc.msgHandler = callback
+}
+
+// GetMessageHandler() returns the (possibly nil) messaging handler callback
+func (svc *PostalService) GetMessageHandler() func(string, string, *launch_helper.HelperOutput) error {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.msgHandler
+}
+
+// Start() dials the bus, grab the name, and listens for method calls.
+func (svc *PostalService) Start() error {
+	return svc.DBusService.Start(bus.DispatchMap{
+		"Notifications": svc.notifications,
+		"Inject":        svc.inject,
+	}, PostalServiceBusAddress)
+}
+
+func (svc *PostalService) TakeTheBus() (<-chan notifications.RawActionReply, error) {
+	iniCh := make(chan uint32)
+	go func() { iniCh <- util.NewAutoRedialer(svc.notificationsEndp).Redial() }()
+	<-iniCh
+	actionsCh, err := notifications.Raw(svc.notificationsEndp, svc.Log).WatchActions()
+	return actionsCh, err
+}
+
+func (svc *PostalService) notifications(path string, args, _ []interface{}) ([]interface{}, error) {
+	if len(args) != 0 {
+		return nil, BadArgCount
+	}
+	appname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
+
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+
+	if svc.mbox == nil {
+		return []interface{}{[]string(nil)}, nil
+	}
+	msgs := svc.mbox[appname]
+	delete(svc.mbox, appname)
+
+	return []interface{}{msgs}, nil
+}
+
+var newNid = uuid.New
+
+func (svc *PostalService) inject(path string, args, _ []interface{}) ([]interface{}, error) {
+	if len(args) != 1 {
+		return nil, BadArgCount
+	}
+	notif, ok := args[0].(string)
+	if !ok {
+		return nil, BadArgType
+	}
+	appname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
+
+	nid := newNid()
+
+	return nil, svc.Inject(appname, nid, notif)
+}
+
+// Inject() signals to an application over dbus that a notification
+// has arrived.
+func (svc *PostalService) Inject(appname string, nid string, notif string) error {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	if svc.mbox == nil {
+		svc.mbox = make(map[string][]string)
+	}
+	output := svc.HelperLauncher.Run(appname, []byte(notif))
+	// XXX also track the nid in the mbox
+	svc.mbox[appname] = append(svc.mbox[appname], string(output.Message))
+
+	if svc.msgHandler != nil {
+		err := svc.msgHandler(appname, nid, output)
+		if err != nil {
+			svc.DBusService.Log.Errorf("msgHandler returned %v", err)
+			return err
+		}
+		svc.DBusService.Log.Debugf("call to msgHandler successful")
+	}
+
+	return svc.Bus.Signal("Notification", "/"+string(nih.Quote([]byte(appname))), []interface{}{appname})
+}
+
+func (svc *PostalService) messageHandler(appname string, nid string, output *launch_helper.HelperOutput) error {
+	svc.messagingMenu.Present(appname, nid, output.Notification)
+	nots := notifications.Raw(svc.notificationsEndp, svc.Log)
+	_, err := nots.Present(appname, nid, output.Notification)
+
+	return err
+}
+
+func (svc *PostalService) SendNotification(action_id, icon, summary, body string) (uint32, error) {
+	a := []string{action_id, "Switch to app"} // action value not visible on the phone
+	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
+	nots := notifications.Raw(svc.notificationsEndp, svc.Log)
+	return nots.Notify(
+		"ubuntu-push-client", // app name
+		uint32(0),            // id
+		icon,                 // icon
+		summary,              // summary
+		body,                 // body
+		a,                    // actions
+		h,                    // hints
+		int32(10*1000),       // timeout (ms)
+	)
+}
 
=== added file 'client/service/postal_test.go'
--- client/service/postal_test.go	1970-01-01 00:00:00 +0000
+++ client/service/postal_test.go	2014-07-02 13:12:36 +0000
@@ -0,0 +1,252 @@
+/*
+ Copyright 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 service
+
+import (
+	"errors"
+
+	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/bus"
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/launch_helper"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+type postalSuite struct {
+	log      *helpers.TestLogger
+	bus      bus.Endpoint
+	notifBus bus.Endpoint
+}
+
+var _ = Suite(&postalSuite{})
+
+func (ss *postalSuite) SetUpTest(c *C) {
+	ss.log = helpers.NewTestLogger(c, "debug")
+	ss.bus = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	ss.notifBus = testibus.NewTestingEndpoint(condition.Work(true), nil)
+}
+
+func (ss *postalSuite) TestStart(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	c.Check(svc.IsRunning(), Equals, false)
+	c.Check(svc.Start(), IsNil)
+	c.Check(svc.IsRunning(), Equals, true)
+	svc.Stop()
+}
+
+func (ss *postalSuite) TestStartTwice(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	c.Check(svc.Start(), IsNil)
+	c.Check(svc.Start(), Equals, AlreadyStarted)
+	svc.Stop()
+}
+
+func (ss *postalSuite) TestStartNoLog(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, nil)
+	c.Check(svc.Start(), Equals, NotConfigured)
+}
+
+func (ss *postalSuite) TestStartNoBus(c *C) {
+	svc := NewPostalService(nil, ss.notifBus, ss.log)
+	c.Check(svc.Start(), Equals, NotConfigured)
+}
+
+func (ss *postalSuite) TestTakeTheBustFail(c *C) {
+	nEndp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), condition.Work(false), []interface{}{uint32(1), "hello"})
+	svc := NewPostalService(ss.bus, nEndp, ss.log)
+	_, err := svc.TakeTheBus()
+	c.Check(err, NotNil)
+}
+
+func (ss *postalSuite) TestTakeTheBustOk(c *C) {
+	nEndp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), condition.Work(true), []interface{}{uint32(1), "hello"})
+	svc := NewPostalService(ss.bus, nEndp, ss.log)
+	_, err := svc.TakeTheBus()
+	c.Check(err, IsNil)
+}
+
+func (ss *postalSuite) TestStartFailsOnBusDialFailure(c *C) {
+	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
+	svc := NewPostalService(bus, ss.notifBus, ss.log)
+	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
+	svc.Stop()
+}
+
+func (ss *postalSuite) TestStartGrabsName(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	c.Assert(svc.Start(), IsNil)
+	callArgs := testibus.GetCallArgs(ss.bus)
+	defer svc.Stop()
+	c.Assert(callArgs, NotNil)
+	c.Check(callArgs[0].Member, Equals, "::GrabName")
+}
+
+func (ss *postalSuite) TestStopClosesBus(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	c.Assert(svc.Start(), IsNil)
+	svc.Stop()
+	callArgs := testibus.GetCallArgs(ss.bus)
+	c.Assert(callArgs, NotNil)
+	c.Check(callArgs[len(callArgs)-1].Member, Equals, "::Close")
+}
+
+//
+// Injection tests
+
+func (ss *postalSuite) TestInjectWorks(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc.msgHandler = nil
+	rvs, err := svc.inject("/hello", []interface{}{"world"}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+	rvs, err = svc.inject("/hello", []interface{}{"there"}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+	c.Assert(svc.mbox, HasLen, 1)
+	c.Assert(svc.mbox["hello"], HasLen, 2)
+	c.Check(svc.mbox["hello"][0], Equals, "world")
+	c.Check(svc.mbox["hello"][1], Equals, "there")
+
+	// and check it fired the right signal (twice)
+	callArgs := testibus.GetCallArgs(ss.bus)
+	c.Assert(callArgs, HasLen, 2)
+	c.Check(callArgs[0].Member, Equals, "::Signal")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"Notification", "/hello", []interface{}{"hello"}})
+	c.Check(callArgs[1], DeepEquals, callArgs[0])
+}
+
+func (ss *postalSuite) TestInjectFailsIfInjectFails(c *C) {
+	bus := testibus.NewTestingEndpoint(condition.Work(true),
+		condition.Work(false))
+	svc := NewPostalService(bus, ss.notifBus, ss.log)
+	svc.SetMessageHandler(func(string, string, *launch_helper.HelperOutput) error { return errors.New("fail") })
+	_, err := svc.inject("/hello", []interface{}{"xyzzy"}, nil)
+	c.Check(err, NotNil)
+}
+
+func (ss *postalSuite) TestInjectFailsIfBadArgs(c *C) {
+	for i, s := range []struct {
+		args []interface{}
+		errt error
+	}{
+		{nil, BadArgCount},
+		{[]interface{}{}, BadArgCount},
+		{[]interface{}{1}, BadArgType},
+		{[]interface{}{1, 2}, BadArgCount},
+	} {
+		reg, err := new(PostalService).inject("", s.args, nil)
+		c.Check(reg, IsNil, Commentf("iteration #%d", i))
+		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
+	}
+}
+
+//
+// Notifications tests
+func (ss *postalSuite) TestNotificationsWorks(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	nots, err := svc.notifications("/hello", nil, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], HasLen, 0)
+	if svc.mbox == nil {
+		svc.mbox = make(map[string][]string)
+	}
+	svc.mbox["hello"] = append(svc.mbox["hello"], "this", "thing")
+	nots, err = svc.notifications("/hello", nil, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], DeepEquals, []string{"this", "thing"})
+}
+
+func (ss *postalSuite) TestNotificationsFailsIfBadArgs(c *C) {
+	reg, err := new(PostalService).notifications("/foo", []interface{}{1}, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadArgCount)
+}
+
+func (ss *postalSuite) TestMessageHandlerPublicAPI(c *C) {
+	svc := new(PostalService)
+	c.Assert(svc.msgHandler, IsNil)
+	var ext = &launch_helper.HelperOutput{}
+	e := errors.New("Hello")
+	f := func(app string, nid string, s *launch_helper.HelperOutput) error { ext = s; return e }
+	c.Check(svc.GetMessageHandler(), IsNil)
+	svc.SetMessageHandler(f)
+	c.Check(svc.GetMessageHandler(), NotNil)
+	hOutput := &launch_helper.HelperOutput{[]byte("37"), nil}
+	c.Check(svc.msgHandler("", "", hOutput), Equals, e)
+	c.Check(ext, DeepEquals, hOutput)
+}
+
+func (ss *postalSuite) TestInjectCallsMessageHandler(c *C) {
+	var ext = &launch_helper.HelperOutput{}
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	f := func(app string, nid string, s *launch_helper.HelperOutput) error { ext = s; return nil }
+	svc.SetMessageHandler(f)
+	c.Check(svc.Inject("stuff", "thing", "{}"), IsNil)
+	c.Check(ext, DeepEquals, &launch_helper.HelperOutput{})
+	err := errors.New("ouch")
+	svc.SetMessageHandler(func(string, string, *launch_helper.HelperOutput) error { return err })
+	c.Check(svc.Inject("stuff", "", "{}"), Equals, err)
+}
+
+func (ss *postalSuite) TestMessageHandler(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	svc := NewPostalService(ss.bus, endp, ss.log)
+	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Body: "body-value", Popup: true}
+	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{Card: card}}
+	err := svc.messageHandler("xyzzy", "", output)
+	c.Assert(err, IsNil)
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "Notify")
+	c.Check(args[0].Args[0], Equals, "xyzzy")
+	c.Check(args[0].Args[2], Equals, "icon-value")
+	c.Check(args[0].Args[3], Equals, "summary-value")
+	c.Check(args[0].Args[4], Equals, "body-value")
+}
+
+func (ss *postalSuite) TestMessageHandlerReportsFailedNotifies(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	svc := NewPostalService(ss.bus, endp, ss.log)
+	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("", "", output)
+	c.Assert(err, NotNil)
+}
+
+func (ss *postalSuite) TestMessageHandlerReportsButIgnoresUnmarshalErrors(c *C) {
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	output := &launch_helper.HelperOutput{[]byte(`broken`), nil}
+	err := svc.messageHandler("", "", output)
+	c.Check(err, IsNil)
+	c.Check(ss.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
+}
+
+func (ss *postalSuite) TestMessageHandlerReportsButIgnoresNilNotifies(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	svc := NewPostalService(ss.bus, endp, ss.log)
+	output := &launch_helper.HelperOutput{[]byte(`{}`), nil}
+	err := svc.messageHandler("", "", output)
+	c.Assert(err, IsNil)
+	c.Check(ss.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
+}
 
=== modified file 'client/service/service.go'
--- client/service/service.go	2014-05-21 10:03:18 +0000
+++ client/service/service.go	2014-07-02 13:12:36 +0000
@@ -14,196 +14,184 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// package service implements the dbus-level service with which client
-// applications are expected to interact.
 package service
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
 	"os"
-	"sync"
+	"strings"
 
 	"launchpad.net/ubuntu-push/bus"
+	http13 "launchpad.net/ubuntu-push/http13client"
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/nih"
 )
 
-// Service is the dbus api
-type Service struct {
-	lock       sync.RWMutex
-	state      ServiceState
-	mbox       map[string][]string
-	msgHandler func([]byte) error
-	Log        logger.Logger
-	Bus        bus.Endpoint
+// PushService is the dbus api
+type PushService struct {
+	DBusService
+	regURL     string
+	deviceId   string
+	authGetter func(string) string
+	httpCli    http13.Client
 }
 
-// the service can be in a numnber of states
-type ServiceState uint8
-
-const (
-	StateUnknown  ServiceState = iota
-	StateRunning               // Start() has been successfully called
-	StateFinished              // Stop() has been successfully called
-)
-
 var (
-	NotConfigured  = errors.New("not configured")
-	AlreadyStarted = errors.New("already started")
-	BusAddress     = bus.Address{
+	PushServiceBusAddress = bus.Address{
 		Interface: "com.ubuntu.PushNotifications",
 		Path:      "/com/ubuntu/PushNotifications",
 		Name:      "com.ubuntu.PushNotifications",
 	}
 )
 
-// NewService() builds a new service and returns it.
-func NewService(bus bus.Endpoint, log logger.Logger) *Service {
-	return &Service{Log: log, Bus: bus}
-}
-
-// SetMessageHandler() sets the message-handling callback
-func (svc *Service) SetMessageHandler(callback func([]byte) error) {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	svc.msgHandler = callback
-}
-
-// GetMessageHandler() returns the (possibly nil) messaging handler callback
-func (svc *Service) GetMessageHandler() func([]byte) error {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	return svc.msgHandler
-}
-
-// IsRunning() returns whether the service's state is StateRunning
-func (svc *Service) IsRunning() bool {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	return svc.state == StateRunning
-}
-
-// Start() dials the bus, grab the name, and listens for method calls.
-func (svc *Service) Start() error {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	if svc.state != StateUnknown {
-		return AlreadyStarted
-	}
-	if svc.Log == nil || svc.Bus == nil {
-		return NotConfigured
-	}
-	err := svc.Bus.Dial()
-	if err != nil {
-		return err
-	}
-	ch := svc.Bus.GrabName(true)
-	log := svc.Log
-	go func() {
-		for err := range ch {
-			if !svc.IsRunning() {
-				break
-			}
-			if err != nil {
-				log.Fatalf("name channel for %s got: %v",
-					BusAddress.Name, err)
-			}
-		}
-	}()
-	svc.Bus.WatchMethod(bus.DispatchMap{
-		"Register":      svc.register,
-		"Notifications": svc.notifications,
-		"Inject":        svc.inject,
-	}, svc)
-	svc.state = StateRunning
-	return nil
-}
-
-// Stop() closes the bus and sets the state to StateFinished
-func (svc *Service) Stop() {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	if svc.Bus != nil {
-		svc.Bus.Close()
-	}
-	svc.state = StateFinished
+// NewPushService() builds a new service and returns it.
+func NewPushService(bus bus.Endpoint, log logger.Logger) *PushService {
+	var svc = &PushService{}
+	svc.Log = log
+	svc.Bus = bus
+	return svc
+}
+
+// SetRegistrationURL() sets the registration url for the service
+func (svc *PushService) SetRegistrationURL(url string) {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	svc.regURL = url
+}
+
+// SetAuthGetter() sets the authorization getter for the service
+func (svc *PushService) SetAuthGetter(authGetter func(string) string) {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	svc.authGetter = authGetter
+}
+
+// getRegistrationAuthorization() returns the authorization header for
+// POSTing to the registration HTTP endpoint
+//
+// (this is for calling with the lock held)
+func (svc *PushService) getRegistrationAuthorization() string {
+	if svc.authGetter != nil && svc.regURL != "" {
+		return svc.authGetter(svc.regURL)
+	} else {
+		return ""
+	}
+}
+
+// GetRegistrationAuthorization() returns the authorization header for
+// POSTing to the registration HTTP endpoint
+func (svc *PushService) GetRegistrationAuthorization() string {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.getRegistrationAuthorization()
+}
+
+// SetDeviceId() sets the device id
+func (svc *PushService) SetDeviceId(deviceId string) {
+	svc.lock.Lock()
+	defer svc.lock.Unlock()
+	svc.deviceId = deviceId
+}
+
+// GetDeviceId() returns the device id
+func (svc *PushService) GetDeviceId() string {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	return svc.deviceId
+}
+
+func (svc *PushService) Start() error {
+	return svc.DBusService.Start(bus.DispatchMap{
+		"Register": svc.register,
+	}, PushServiceBusAddress)
 }
 
 var (
-	BadArgCount = errors.New("Wrong number of arguments")
-	BadArgType  = errors.New("Bad argument type")
+	BadServer  = errors.New("Bad server")
+	BadRequest = errors.New("Bad request")
+	BadToken   = errors.New("Bad token")
+	BadAuth    = errors.New("Bad auth")
 )
 
-func (svc *Service) register(args []interface{}, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 1 {
-		return nil, BadArgCount
-	}
-	appname, ok := args[0].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-
-	rv := os.Getenv("PUSH_REG_" + appname)
-	if rv == "" {
-		rv = "this-is-an-opaque-block-of-random-bits-i-promise"
-	}
-
-	return []interface{}{rv}, nil
-}
-
-func (svc *Service) notifications(args []interface{}, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 1 {
-		return nil, BadArgCount
-	}
-	appname, ok := args[0].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-
-	if svc.mbox == nil {
-		return []interface{}{[]string(nil)}, nil
-	}
-	msgs := svc.mbox[appname]
-	delete(svc.mbox, appname)
-
-	return []interface{}{msgs}, nil
-}
-
-func (svc *Service) inject(args []interface{}, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 2 {
-		return nil, BadArgCount
-	}
-	appname, ok := args[0].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-	notif, ok := args[1].(string)
-	if !ok {
-		return nil, BadArgType
-	}
-
-	return nil, svc.Inject(appname, notif)
-}
-
-// Inject() signals to an application over dbus that a notification
-// has arrived.
-func (svc *Service) Inject(appname string, notif string) error {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	if svc.mbox == nil {
-		svc.mbox = make(map[string][]string)
-	}
-	svc.mbox[appname] = append(svc.mbox[appname], notif)
-	if svc.msgHandler != nil {
-		err := svc.msgHandler([]byte(notif))
-		if err != nil {
-			svc.Log.Errorf("msgHandler returned %v", err)
-			return err
+type registrationRequest struct {
+	DeviceId string `json:"deviceid"`
+	AppId    string `json:"appid"`
+}
+
+type registrationReply struct {
+	Token   string `json:"token"`   // the bit we're after
+	Ok      bool   `json:"ok"`      // only ever true or absent
+	Error   string `json:"error"`   // these two only used for debugging
+	Message string `json:"message"` //
+}
+
+func (svc *PushService) register(path string, args, _ []interface{}) ([]interface{}, error) {
+	svc.lock.RLock()
+	defer svc.lock.RUnlock()
+	if len(args) != 0 {
+		return nil, BadArgCount
+	}
+	raw_appname := path[strings.LastIndex(path, "/")+1:]
+	appname := string(nih.Unquote([]byte(raw_appname)))
+
+	rv := os.Getenv("PUSH_REG_" + raw_appname)
+	if rv != "" {
+		return []interface{}{rv}, nil
+	}
+
+	req_body, err := json.Marshal(registrationRequest{svc.deviceId, appname})
+	if err != nil {
+		return nil, fmt.Errorf("unable to marshal register request body: %v", err)
+	}
+	req, err := http13.NewRequest("POST", svc.regURL, bytes.NewReader(req_body))
+	if err != nil {
+		return nil, fmt.Errorf("unable to build register request: %v", err)
+	}
+	auth := svc.getRegistrationAuthorization()
+	if auth == "" {
+		return nil, BadAuth
+	}
+	req.Header.Add("Authorization", auth)
+	req.Header.Add("Content-Type", "application/json")
+
+	resp, err := svc.httpCli.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("unable to request registration: %v", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		svc.Log.Errorf("register endpoint replied %d", resp.StatusCode)
+		switch {
+		case resp.StatusCode >= http.StatusInternalServerError:
+			// XXX retry on 503
+			return nil, BadServer
+		default:
+			return nil, BadRequest
 		}
-		svc.Log.Debugf("call to msgHandler successful")
-	}
-
-	return svc.Bus.Signal("Notification", []interface{}{appname})
+	}
+	// errors below here Can't Happen (tm).
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		svc.Log.Errorf("Reading response body: %v", err)
+		return nil, err
+	}
+
+	var reply registrationReply
+	err = json.Unmarshal(body, &reply)
+	if err != nil {
+		svc.Log.Errorf("Unmarshalling response body: %v", err)
+		return nil, fmt.Errorf("unable to unmarshal register response: %v", err)
+	}
+
+	if !reply.Ok || reply.Token == "" {
+		svc.Log.Errorf("Unexpected response: %#v", reply)
+		return nil, BadToken
+	}
+
+	return []interface{}{reply.Token}, nil
 }
 
=== modified file 'client/service/service_test.go'
--- client/service/service_test.go	2014-05-21 10:05:24 +0000
+++ client/service/service_test.go	2014-07-02 13:12:36 +0000
@@ -17,7 +17,10 @@
 package service
 
 import (
-	"errors"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"testing"
 
@@ -45,7 +48,7 @@
 }
 
 func (ss *serviceSuite) TestStart(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Check(svc.IsRunning(), Equals, false)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.IsRunning(), Equals, true)
@@ -53,31 +56,31 @@
 }
 
 func (ss *serviceSuite) TestStartTwice(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.Start(), Equals, AlreadyStarted)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartNoLog(c *C) {
-	svc := NewService(ss.bus, nil)
+	svc := NewPushService(ss.bus, nil)
 	c.Check(svc.Start(), Equals, NotConfigured)
 }
 
 func (ss *serviceSuite) TestStartNoBus(c *C) {
-	svc := NewService(nil, ss.log)
+	svc := NewPushService(nil, ss.log)
 	c.Check(svc.Start(), Equals, NotConfigured)
 }
 
 func (ss *serviceSuite) TestStartFailsOnBusDialFailure(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
-	svc := NewService(bus, ss.log)
+	svc := NewPushService(bus, ss.log)
 	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartGrabsName(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	callArgs := testibus.GetCallArgs(ss.bus)
 	defer svc.Stop()
@@ -86,7 +89,7 @@
 }
 
 func (ss *serviceSuite) TestStopClosesBus(c *C) {
-	svc := NewService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	svc.Stop()
 	callArgs := testibus.GetCallArgs(ss.bus)
@@ -96,36 +99,75 @@
 
 // registration tests
 
+func (ss *serviceSuite) TestSetRegURLWorks(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	c.Check(svc.regURL, Equals, "")
+	svc.SetRegistrationURL("xyzzy://")
+	c.Check(svc.regURL, Equals, "xyzzy://")
+}
+
+func (ss *serviceSuite) TestSetAuthGetterWorks(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	c.Check(svc.authGetter, IsNil)
+	f := func(string) string { return "" }
+	svc.SetAuthGetter(f)
+	c.Check(fmt.Sprintf("%#v", svc.authGetter), Equals, fmt.Sprintf("%#v", f))
+}
+
+func (ss *serviceSuite) TestGetRegAuthWorks(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetRegistrationURL("xyzzy://")
+	ch := make(chan string, 1)
+	f := func(s string) string { ch <- s; return "Auth " + s }
+	svc.SetAuthGetter(f)
+	c.Check(svc.getRegistrationAuthorization(), Equals, "Auth xyzzy://")
+	c.Assert(len(ch), Equals, 1)
+	c.Check(<-ch, Equals, "xyzzy://")
+}
+
+func (ss *serviceSuite) TestGetRegAuthDoesNotPanic(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	c.Check(svc.getRegistrationAuthorization(), Equals, "")
+}
+
 func (ss *serviceSuite) TestRegistrationFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, BadArgCount},                 // no args
-		{[]interface{}{}, BadArgCount},     // still no args
-		{[]interface{}{42}, BadArgType},    // bad arg type
-		{[]interface{}{1, 2}, BadArgCount}, // too many args
-	} {
-		reg, err := new(Service).register(s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
+	reg, err := new(PushService).register("", []interface{}{1}, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadArgCount)
 }
 
 func (ss *serviceSuite) TestRegistrationWorks(c *C) {
-	reg, err := new(Service).register([]interface{}{"this"}, nil)
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"ok":true,"token":"blob-of-bytes"}`)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	svc.SetDeviceId("fake-device-id")
+	// this'll check (un)quoting, too
+	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	c.Assert(err, IsNil)
 	c.Assert(reg, HasLen, 1)
 	regs, ok := reg[0].(string)
 	c.Check(ok, Equals, true)
-	c.Check(regs, Not(Equals), "")
-	c.Check(err, IsNil)
+	c.Check(regs, Equals, "blob-of-bytes")
 }
 
 func (ss *serviceSuite) TestRegistrationOverrideWorks(c *C) {
 	os.Setenv("PUSH_REG_stuff", "42")
 	defer os.Setenv("PUSH_REG_stuff", "")
 
-	reg, err := new(Service).register([]interface{}{"stuff"}, nil)
+	reg, err := new(PushService).register("/stuff", nil, nil)
 	c.Assert(reg, HasLen, 1)
 	regs, ok := reg[0].(string)
 	c.Check(ok, Equals, true)
@@ -133,115 +175,103 @@
 	c.Check(err, IsNil)
 }
 
-//
-// Injection tests
-
-func (ss *serviceSuite) TestInjectWorks(c *C) {
-	svc := NewService(ss.bus, ss.log)
-	rvs, err := svc.inject([]interface{}{"hello", "world"}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	rvs, err = svc.inject([]interface{}{"hello", "there"}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	c.Assert(svc.mbox, HasLen, 1)
-	c.Assert(svc.mbox["hello"], HasLen, 2)
-	c.Check(svc.mbox["hello"][0], Equals, "world")
-	c.Check(svc.mbox["hello"][1], Equals, "there")
-
-	// and check it fired the right signal (twice)
-	callArgs := testibus.GetCallArgs(ss.bus)
-	c.Assert(callArgs, HasLen, 2)
-	c.Check(callArgs[0].Member, Equals, "::Signal")
-	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"Notification", []interface{}{"hello"}})
-	c.Check(callArgs[1], DeepEquals, callArgs[0])
-}
-
-func (ss *serviceSuite) TestInjectFailsIfInjectFails(c *C) {
-	bus := testibus.NewTestingEndpoint(condition.Work(true),
-		condition.Work(false))
-	svc := NewService(bus, ss.log)
-	svc.SetMessageHandler(func([]byte) error { return errors.New("fail") })
-	_, err := svc.inject([]interface{}{"hello", "xyzzy"}, nil)
-	c.Check(err, NotNil)
-}
-
-func (ss *serviceSuite) TestInjectFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, BadArgCount},
-		{[]interface{}{}, BadArgCount},
-		{[]interface{}{1}, BadArgCount},
-		{[]interface{}{1, 2}, BadArgType},
-		{[]interface{}{"1", 2}, BadArgType},
-		{[]interface{}{1, "2"}, BadArgType},
-		{[]interface{}{1, 2, 3}, BadArgCount},
-	} {
-		reg, err := new(Service).inject(s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
-}
-
-//
-// Notifications tests
-func (ss *serviceSuite) TestNotificationsWorks(c *C) {
-	svc := NewService(ss.bus, ss.log)
-	nots, err := svc.notifications([]interface{}{"hello"}, nil)
-	c.Assert(err, IsNil)
-	c.Assert(nots, NotNil)
-	c.Assert(nots, HasLen, 1)
-	c.Check(nots[0], HasLen, 0)
-	if svc.mbox == nil {
-		svc.mbox = make(map[string][]string)
-	}
-	svc.mbox["hello"] = append(svc.mbox["hello"], "this", "thing")
-	nots, err = svc.notifications([]interface{}{"hello"}, nil)
-	c.Assert(err, IsNil)
-	c.Assert(nots, NotNil)
-	c.Assert(nots, HasLen, 1)
-	c.Check(nots[0], DeepEquals, []string{"this", "thing"})
-}
-
-func (ss *serviceSuite) TestNotificationsFailsIfBadArgs(c *C) {
-	for i, s := range []struct {
-		args []interface{}
-		errt error
-	}{
-		{nil, BadArgCount},                 // no args
-		{[]interface{}{}, BadArgCount},     // still no args
-		{[]interface{}{42}, BadArgType},    // bad arg type
-		{[]interface{}{1, 2}, BadArgCount}, // too many args
-	} {
-		reg, err := new(Service).notifications(s.args, nil)
-		c.Check(reg, IsNil, Commentf("iteration #%d", i))
-		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
-	}
-}
-
-func (ss *serviceSuite) TestMessageHandler(c *C) {
-	svc := new(Service)
-	c.Assert(svc.msgHandler, IsNil)
-	var ext = []byte{}
-	e := errors.New("Hello")
-	f := func(s []byte) error { ext = s; return e }
-	c.Check(svc.GetMessageHandler(), IsNil)
-	svc.SetMessageHandler(f)
-	c.Check(svc.GetMessageHandler(), NotNil)
-	c.Check(svc.msgHandler([]byte("37")), Equals, e)
-	c.Check(ext, DeepEquals, []byte("37"))
-}
-
-func (ss *serviceSuite) TestInjectCallsMessageHandler(c *C) {
-	var ext = []byte{}
-	svc := NewService(ss.bus, ss.log)
-	f := func(s []byte) error { ext = s; return nil }
-	svc.SetMessageHandler(f)
-	c.Check(svc.Inject("stuff", "{}"), IsNil)
-	c.Check(ext, DeepEquals, []byte("{}"))
-	err := errors.New("ouch")
-	svc.SetMessageHandler(func([]byte) error { return err })
-	c.Check(svc.Inject("stuff", "{}"), Equals, err)
+func (ss *serviceSuite) TestRegistrationFailsOnBadReqURL(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetRegistrationURL("%gh")
+	reg, err := svc.register("thing", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, ErrorMatches, "unable to build register request: .*")
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnBadAuth(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	// ... no auth added
+	reg, err := svc.register("thing", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadAuth)
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnNoServer(c *C) {
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetRegistrationURL("xyzzy://")
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	reg, err := svc.register("thing", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, ErrorMatches, "unable to request registration: .*")
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOn40x(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "I'm a teapot", 418)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	reg, err := svc.register("/thing", nil, nil)
+	c.Check(err, Equals, BadRequest)
+	c.Check(reg, IsNil)
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOn50x(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "Not implemented", 501)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	reg, err := svc.register("/thing", nil, nil)
+	c.Check(err, Equals, BadServer)
+	c.Check(reg, IsNil)
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnBadJSON(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{`)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	svc.SetDeviceId("fake-device-id")
+	// this'll check (un)quoting, too
+	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, ErrorMatches, "unable to unmarshal register response: .*")
+}
+
+func (ss *serviceSuite) TestRegistrationFailsOnBadJSONDocument(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"bananas": "very yes"}`)
+	}))
+	defer ts.Close()
+
+	svc := NewPushService(ss.bus, ss.log)
+	svc.SetAuthGetter(func(string) string { return "tok" })
+	svc.SetRegistrationURL(ts.URL)
+	svc.SetDeviceId("fake-device-id")
+	// this'll check (un)quoting, too
+	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	c.Check(reg, IsNil)
+	c.Check(err, Equals, BadToken)
 }
 
=== modified file 'client/session/session.go'
--- client/session/session.go	2014-05-23 05:59:38 +0000
+++ client/session/session.go	2014-07-02 13:12:36 +0000
@@ -26,7 +26,6 @@
 	"fmt"
 	"math/rand"
 	"net"
-	"os/exec"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -87,7 +86,8 @@
 	ExpectAllRepairedTime  time.Duration
 	PEM                    []byte
 	Info                   map[string]interface{}
-	AuthHelper             []string
+	AuthGetter             func(string) string
+	AuthURL                string
 }
 
 // ClientSession holds a client<->server session and its configuration.
@@ -244,21 +244,10 @@
 // addAuthorization gets the authorization blob to send to the server
 // and adds it to the session.
 func (sess *ClientSession) addAuthorization() error {
-	sess.Log.Debugf("adding authorization")
-	// using a helper, for now at least
-	if len(sess.AuthHelper) == 0 {
-		// do nothing if helper is unset or empty
-		return nil
-	}
-
-	auth, err := exec.Command(sess.AuthHelper[0], sess.AuthHelper[1:]...).Output()
-	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)
-	} else {
-		sess.auth = strings.TrimSpace(string(auth))
-	}
-
+	if sess.AuthGetter != nil {
+		sess.Log.Debugf("adding authorization")
+		sess.auth = sess.AuthGetter(sess.AuthURL)
+	}
 	return nil
 }
 
 
=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-05-23 05:59:38 +0000
+++ client/session/session_test.go	2014-07-02 13:12:36 +0000
@@ -353,34 +353,21 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestAddAuthorizationAddsAuthorization(c *C) {
-	sess := &ClientSession{Log: cs.log}
-	sess.AuthHelper = []string{"echo", "some auth"}
-	c.Assert(sess.auth, Equals, "")
-	err := sess.addAuthorization()
-	c.Assert(err, IsNil)
-	c.Check(sess.auth, Equals, "some auth")
-}
-
-func (cs *clientSessionSuite) TestAddAuthorizationIgnoresErrors(c *C) {
-	sess := &ClientSession{Log: cs.log}
-	sess.AuthHelper = []string{"sh", "-c", "echo hello; false"}
-
-	c.Assert(sess.auth, Equals, "")
-	err := sess.addAuthorization()
-	c.Assert(err, IsNil)
-	c.Check(sess.auth, Equals, "")
-}
-
-func (cs *clientSessionSuite) TestAddAuthorizationSkipsIfUnsetOrNil(c *C) {
-	sess := &ClientSession{Log: cs.log}
-	sess.AuthHelper = nil
-	c.Assert(sess.auth, Equals, "")
-	err := sess.addAuthorization()
-	c.Assert(err, IsNil)
-	c.Check(sess.auth, Equals, "")
-
-	sess.AuthHelper = []string{}
-	err = sess.addAuthorization()
+	url := "xyzzy://"
+	sess := &ClientSession{Log: cs.log}
+	sess.AuthGetter = func(url string) string { return url + " auth'ed" }
+	sess.AuthURL = url
+	c.Assert(sess.auth, Equals, "")
+	err := sess.addAuthorization()
+	c.Assert(err, IsNil)
+	c.Check(sess.auth, Equals, "xyzzy:// auth'ed")
+}
+
+func (cs *clientSessionSuite) TestAddAuthorizationSkipsIfUnset(c *C) {
+	sess := &ClientSession{Log: cs.log}
+	sess.AuthGetter = nil
+	c.Assert(sess.auth, Equals, "")
+	err := sess.addAuthorization()
 	c.Assert(err, IsNil)
 	c.Check(sess.auth, Equals, "")
 }
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-06-05 09:42:22 +0000
+++ debian/changelog	2014-07-02 13:12:36 +0000
@@ -1,3 +1,37 @@
+ubuntu-push (0.42ubuntu1) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * Support registering tokens and sending notifications with a token
+  * Register script and scripts unicast support
+  * Update http13client from the actual go1.3 release
+  * Avoid late pings in the face of nop exchanges
+  * murmur3 upstream change of seed to 0
+
+  [ Roberto Alsina ]
+  * Make signing-helper generate a HTTP header instead of a querystring,
+    and take a URL to sign.
+  * Wrap libmessaging-menu to allow for persistent notifications.
+  * Wrap ubuntu-app-launch start_helper / stop_helper functions.
+
+  [ John R. Lenton ]
+  * Switch dbus api to retrieve app name from dbus path.
+  * Move signing bits up from session to client, for reuse by service.
+  * Change AuthHelper to be a string; auth helper should now expect a
+    parameter (the url to sign). Added SessionURL to config.
+  * Adapt our whoopsie wrapper to whoopsie's now more correct behavior wrt
+    failing to get a mac address.
+  * Add registration_url to config; hook up auth bits and reg url to
+    client & service.
+  * Do an HTTP POST to registration_url on register.
+  * Fix debian/rules so packaging-time tests pass (ugh)
+  * Refactoring notification providers.
+  * Get the small messaging-menu wrapper working (thanks larsu & dednick)
+
+  [ Guillermo Gonzalez ]
+  * Split DBus service into PushService and PostalService
+
+ -- John R. Lenton <[e-mail]>  Wed, 02 Jul 2014 13:49:01 +0100
+
 ubuntu-push (0.3+14.10.20140605-0ubuntu1) utopic; urgency=medium
 
   [ John Lenton ]
 
=== modified file 'debian/config.json'
--- debian/config.json	2014-06-04 12:18:42 +0000
+++ debian/config.json	2014-07-02 13:12:36 +0000
@@ -1,5 +1,7 @@
 {
-    "auth_helper": [],
+    "auth_helper": "/usr/lib/ubuntu-push-client/signing-helper",
+    "session_url": "https://push.ubuntu.com/",
+    "registration_url": "https://push.ubuntu.com/register",
     "connect_timeout": "20s",
     "exchange_timeout": "30s",
     "hosts_cache_expiry": "12h",
 
=== modified file 'debian/control'
--- debian/control	2014-06-02 10:01:13 +0000
+++ debian/control	2014-07-02 13:12:36 +0000
@@ -14,7 +14,9 @@
                golang-uuid-dev,
                libgcrypt11-dev,
                libglib2.0-dev (>= 2.31.6),
+               libmessaging-menu-dev,
                libwhoopsie-dev,
+               libubuntu-app-launch2-dev,
                libubuntuoneauth-2.0-dev,
                libdbus-1-dev,
                libnih-dbus-dev,
 
=== modified file 'debian/rules'
--- debian/rules	2014-05-02 12:42:27 +0000
+++ debian/rules	2014-07-02 13:12:36 +0000
@@ -5,10 +5,15 @@
 export UBUNTU_PUSH_TEST_RESOURCES_ROOT := $(CURDIR)
 
 override_dh_auto_build:
-	cd $$( find ./ -type d -regex '\./[^/]*/src/launchpad.net' -printf "%h\n" | head -n1)
 	dh_auto_build --buildsystem=golang
 	(cd signing-helper && cmake . && make)
 
+# overriding dh_auto_test because the http13client tests don't all pass on go < 1.3
+# (should go away once we ship go 1.3)
+override_dh_auto_test:
+	cd $$( find ./ -type d -regex '\./[^/]*/src/launchpad.net' -printf "%h\n" | head -n1) && \
+	env GOPATH=$$(cd ..; pwd) go test $$(env GOPATH=$$(cd ..; pwd) go list $(DH_GOPKG)/... | grep -v acceptance | grep -v http13client )
+
 override_dh_install:
 	dh_install -Xusr/bin/cmd -Xusr/bin/dev --fail-missing
 
 
=== modified file 'external/README'
--- external/README	2014-03-24 15:37:36 +0000
+++ external/README	2014-07-02 13:12:36 +0000
@@ -1,3 +1,3 @@
 Directly included vendorized small packages.
 
-* murmor3 comes from import at lp:~ubuntu-push-hackers/ubuntu-push/murmur at revno 10
+* murmur3 comes from import at lp:~ubuntu-push-hackers/ubuntu-push/murmur at revno 12
 
=== modified file 'external/murmur3/murmur128.go'
--- external/murmur3/murmur128.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur128.go	2014-07-02 13:12:36 +0000
@@ -40,7 +40,7 @@
 
 func (d *digest128) Size() int { return 16 }
 
-func (d *digest128) reset() { d.h1, d.h2 = 1, 1 }
+func (d *digest128) reset() { d.h1, d.h2 = 0, 0 }
 
 func (d *digest128) Sum(b []byte) []byte {
 	h1, h2 := d.h1, d.h2
@@ -182,7 +182,7 @@
 //     hasher.Write(data)
 //     return hasher.Sum128()
 func Sum128(data []byte) (h1 uint64, h2 uint64) {
-	d := &digest128{h1: 1, h2: 1}
+	d := &digest128{h1: 0, h2: 0}
 	d.tail = d.bmix(data)
 	d.clen = len(data)
 	return d.Sum128()
 
=== modified file 'external/murmur3/murmur32.go'
--- external/murmur3/murmur32.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur32.go	2014-07-02 13:12:36 +0000
@@ -33,7 +33,7 @@
 
 func (d *digest32) Size() int { return 4 }
 
-func (d *digest32) reset() { d.h1 = 1 }
+func (d *digest32) reset() { d.h1 = 0 }
 
 func (d *digest32) Sum(b []byte) []byte {
 	h := d.h1
@@ -104,7 +104,7 @@
 //     return hasher.Sum32()
 func Sum32(data []byte) uint32 {
 
-	var h1 uint32 = 1
+	var h1 uint32 = 0
 
 	nblocks := len(data) / 4
 	var p uintptr
 
=== modified file 'external/murmur3/murmur64.go'
--- external/murmur3/murmur64.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur64.go	2014-07-02 13:12:36 +0000
@@ -37,7 +37,7 @@
 //     hasher.Write(data)
 //     return hasher.Sum64()
 func Sum64(data []byte) uint64 {
-	d := &digest128{h1: 1, h2: 1}
+	d := &digest128{h1: 0, h2: 0}
 	d.tail = d.bmix(data)
 	d.clen = len(data)
 	h1, _ := d.Sum128()
 
=== modified file 'external/murmur3/murmur_test.go'
--- external/murmur3/murmur_test.go	2014-03-24 15:31:42 +0000
+++ external/murmur3/murmur_test.go	2014-07-02 13:12:36 +0000
@@ -11,11 +11,11 @@
 	h64_2 uint64
 	s     string
 }{
-	{0x514e28b7, 0x4610abe56eff5cb5, 0x51622daa78f83583, ""},
-	{0xbb4abcad, 0xa78ddff5adae8d10, 0x128900ef20900135, "hello"},
-	{0x6f5cb2e9, 0x8b95f808840725c6, 0x1597ed5422bd493b, "hello, world"},
-	{0xf50e1f30, 0x2a929de9c8f97b2f, 0x56a41d99af43a2db, "19 Jan 2038 at 3:14:07 AM"},
-	{0x846f6a36, 0xfb3325171f9744da, 0xaaf8b92a5f722952, "The quick brown fox jumps over the lazy dog."},
+	{0x00000000, 0x0000000000000000, 0x0000000000000000, ""},
+	{0x248bfa47, 0xcbd8a7b341bd9b02, 0x5b1e906a48ae1d19, "hello"},
+	{0x149bbb7f, 0x342fac623a5ebc8e, 0x4cdcbc079642414d, "hello, world"},
+	{0xe31e8a70, 0xb89e5988b737affc, 0x664fc2950231b2cb, "19 Jan 2038 at 3:14:07 AM"},
+	{0xd5c48bfc, 0xcd99481f9ee902c9, 0x695da1a38987b6e7, "The quick brown fox jumps over the lazy dog."},
 }
 
 func TestRef(t *testing.T) {
@@ -37,6 +37,10 @@
 			t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h64_1)
 		}
 
+		if v := Sum64([]byte(elem.s)); v != elem.h64_1 {
+			t.Errorf("'%s': 0x%x (want 0x%x)", elem.s, v, elem.h64_1)
+		}
+
 		var h128 Hash128 = New128()
 		h128.Write([]byte(elem.s))
 		if v1, v2 := h128.Sum128(); v1 != elem.h64_1 || v2 != elem.h64_2 {
 
=== modified file 'http13client/Makefile'
--- http13client/Makefile	2014-03-20 12:15:36 +0000
+++ http13client/Makefile	2014-07-02 13:12:36 +0000
@@ -20,7 +20,8 @@
 
 prune:
 	rm -rf example_test.go filetransport*.go fs*.go race.go range_test.go \
-	sniff*.go httptest httputil testdata triv.go jar.go status.go
+	sniff*.go httptest httputil testdata triv.go jar.go status.go \
+	cookie_test.go
 	sed -i -e 's+"launchpad.net/ubuntu-push/http13client/+"net/http/+' *.go
 
 fix:
 
=== modified file 'http13client/_patches/empty_server.patch'
--- http13client/_patches/empty_server.patch	2014-03-19 23:13:58 +0000
+++ http13client/_patches/empty_server.patch	2014-07-02 13:12:36 +0000
@@ -1,6 +1,6 @@
 === modified file 'http13client/serve_test.go'
---- http13client/serve_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/serve_test.go	2014-03-19 22:27:37 +0000
+--- http13client/serve_test.go	2014-06-20 11:00:47 +0000
++++ http13client/serve_test.go	2014-06-20 12:00:22 +0000
 @@ -2,60 +2,15 @@
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
@@ -62,7 +62,7 @@
  
  func (a dummyAddr) Network() string {
  	return string(a)
-@@ -93,1289 +48,6 @@
+@@ -93,1325 +48,6 @@
  	return nil
  }
  
@@ -906,31 +906,50 @@
 -}
 -
 -type serverExpectTest struct {
--	contentLength    int    // of request body
+-	contentLength    int // of request body
+-	chunked          bool
 -	expectation      string // e.g. "100-continue"
 -	readBody         bool   // whether handler should read the body (if false, sends StatusUnauthorized)
 -	expectedResponse string // expected substring in first line of http response
 -}
 -
+-func expectTest(contentLength int, expectation string, readBody bool, expectedResponse string) serverExpectTest {
+-	return serverExpectTest{
+-		contentLength:    contentLength,
+-		expectation:      expectation,
+-		readBody:         readBody,
+-		expectedResponse: expectedResponse,
+-	}
+-}
+-
 -var serverExpectTests = []serverExpectTest{
 -	// Normal 100-continues, case-insensitive.
--	{100, "100-continue", true, "100 Continue"},
--	{100, "100-cOntInUE", true, "100 Continue"},
+-	expectTest(100, "100-continue", true, "100 Continue"),
+-	expectTest(100, "100-cOntInUE", true, "100 Continue"),
 -
 -	// No 100-continue.
--	{100, "", true, "200 OK"},
+-	expectTest(100, "", true, "200 OK"),
 -
 -	// 100-continue but requesting client to deny us,
 -	// so it never reads the body.
--	{100, "100-continue", false, "401 Unauthorized"},
+-	expectTest(100, "100-continue", false, "401 Unauthorized"),
 -	// Likewise without 100-continue:
--	{100, "", false, "401 Unauthorized"},
+-	expectTest(100, "", false, "401 Unauthorized"),
 -
 -	// Non-standard expectations are failures
--	{0, "a-pony", false, "417 Expectation Failed"},
+-	expectTest(0, "a-pony", false, "417 Expectation Failed"),
 -
--	// Expect-100 requested but no body
--	{0, "100-continue", true, "400 Bad Request"},
+-	// Expect-100 requested but no body (is apparently okay: Issue 7625)
+-	expectTest(0, "100-continue", true, "200 OK"),
+-	// Expect-100 requested but handler doesn't read the body
+-	expectTest(0, "100-continue", false, "401 Unauthorized"),
+-	// Expect-100 continue with no body, but a chunked body.
+-	{
+-		expectation:      "100-continue",
+-		readBody:         true,
+-		chunked:          true,
+-		expectedResponse: "100 Continue",
+-	},
 -}
 -
 -// Tests that the server responds to the "Expect" request header
@@ -959,21 +978,38 @@
 -
 -		// Only send the body immediately if we're acting like an HTTP client
 -		// that doesn't send 100-continue expectations.
--		writeBody := test.contentLength > 0 && strings.ToLower(test.expectation) != "100-continue"
+-		writeBody := test.contentLength != 0 && strings.ToLower(test.expectation) != "100-continue"
 -
 -		go func() {
+-			contentLen := fmt.Sprintf("Content-Length: %d", test.contentLength)
+-			if test.chunked {
+-				contentLen = "Transfer-Encoding: chunked"
+-			}
 -			_, err := fmt.Fprintf(conn, "POST /?readbody=%v HTTP/1.1\r\n"+
 -				"Connection: close\r\n"+
--				"Content-Length: %d\r\n"+
+-				"%s\r\n"+
 -				"Expect: %s\r\nHost: foo\r\n\r\n",
--				test.readBody, test.contentLength, test.expectation)
+-				test.readBody, contentLen, test.expectation)
 -			if err != nil {
 -				t.Errorf("On test %#v, error writing request headers: %v", test, err)
 -				return
 -			}
 -			if writeBody {
+-				var targ io.WriteCloser = struct {
+-					io.Writer
+-					io.Closer
+-				}{
+-					conn,
+-					ioutil.NopCloser(nil),
+-				}
+-				if test.chunked {
+-					targ = httputil.NewChunkedWriter(conn)
+-				}
 -				body := strings.Repeat("A", test.contentLength)
--				_, err = fmt.Fprint(conn, body)
+-				_, err = fmt.Fprint(targ, body)
+-				if err == nil {
+-					err = targ.Close()
+-				}
 -				if err != nil {
 -					if !test.readBody {
 -						// Server likely already hung up on us.
@@ -1352,7 +1388,7 @@
  type neverEnding byte
  
  func (b neverEnding) Read(p []byte) (n int, err error) {
-@@ -1384,1344 +56,3 @@
+@@ -1420,1392 +56,3 @@
  	}
  	return len(p), nil
  }
@@ -2080,7 +2116,7 @@
 -			got := ht.rawResponse(req)
 -			wantStatus := fmt.Sprintf("%d %s", code, StatusText(code))
 -			if !strings.Contains(got, wantStatus) {
--				t.Errorf("Code %d: Wanted %q Modified for %q: %s", code, req, got)
+-				t.Errorf("Code %d: Wanted %q Modified for %q: %s", code, wantStatus, req, got)
 -			} else if strings.Contains(got, "Content-Length") {
 -				t.Errorf("Code %d: Got a Content-Length from %q: %s", code, req, got)
 -			} else if strings.Contains(got, "stuff") {
@@ -2090,6 +2126,21 @@
 -	}
 -}
 -
+-func TestContentTypeOkayOn204(t *testing.T) {
+-	ht := newHandlerTest(HandlerFunc(func(w ResponseWriter, r *Request) {
+-		w.Header().Set("Content-Length", "123") // suppressed
+-		w.Header().Set("Content-Type", "foo/bar")
+-		w.WriteHeader(204)
+-	}))
+-	got := ht.rawResponse("GET / HTTP/1.1")
+-	if !strings.Contains(got, "Content-Type: foo/bar") {
+-		t.Errorf("Response = %q; want Content-Type: foo/bar", got)
+-	}
+-	if strings.Contains(got, "Content-Length: 123") {
+-		t.Errorf("Response = %q; don't want a Content-Length", got)
+-	}
+-}
+-
 -// Issue 6995
 -// A server Handler can receive a Request, and then turn around and
 -// give a copy of that Request.Body out to the Transport (e.g. any
@@ -2261,7 +2312,7 @@
 -	ts.Config.ErrorLog = log.New(ioutil.Discard, "", 0)
 -	ts.Config.ConnState = func(c net.Conn, state ConnState) {
 -		if c == nil {
--			t.Error("nil conn seen in state %s", state)
+-			t.Errorf("nil conn seen in state %s", state)
 -			return
 -		}
 -		mu.Lock()
@@ -2397,6 +2448,39 @@
 -	}
 -}
 -
+-// golang.org/issue/7856
+-func TestServerEmptyBodyRace(t *testing.T) {
+-	defer afterTest(t)
+-	var n int32
+-	ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, req *Request) {
+-		atomic.AddInt32(&n, 1)
+-	}))
+-	defer ts.Close()
+-	var wg sync.WaitGroup
+-	const reqs = 20
+-	for i := 0; i < reqs; i++ {
+-		wg.Add(1)
+-		go func() {
+-			defer wg.Done()
+-			res, err := Get(ts.URL)
+-			if err != nil {
+-				t.Error(err)
+-				return
+-			}
+-			defer res.Body.Close()
+-			_, err = io.Copy(ioutil.Discard, res.Body)
+-			if err != nil {
+-				t.Error(err)
+-				return
+-			}
+-		}()
+-	}
+-	wg.Wait()
+-	if got := atomic.LoadInt32(&n); got != reqs {
+-		t.Errorf("handler ran %d times; want %d", got, reqs)
+-	}
+-}
+-
 -func TestServerConnStateNew(t *testing.T) {
 -	sawNew := false // if the test is buggy, we'll race on this variable.
 -	srv := &Server{
@@ -2699,9 +2783,9 @@
 -}
 
 === modified file 'http13client/server.go'
---- http13client/server.go	2014-03-19 20:20:19 +0000
-+++ http13client/server.go	2014-03-19 22:27:37 +0000
-@@ -2,1984 +2,17 @@
+--- http13client/server.go	2014-06-20 11:00:47 +0000
++++ http13client/server.go	2014-06-20 12:05:53 +0000
+@@ -2,1976 +2,16 @@
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
@@ -2723,7 +2807,7 @@
 -	"path"
 -	"runtime"
 -	"strconv"
- 	"strings"
+-	"strings"
  	"sync"
 -	"sync/atomic"
 -	"time"
@@ -3506,18 +3590,16 @@
 -	}
 -
 -	code := w.status
--	if !bodyAllowedForStatus(code) {
--		// Must not have body.
--		// RFC 2616 section 10.3.5: "the response MUST NOT include other entity-headers"
--		for _, k := range []string{"Content-Type", "Content-Length", "Transfer-Encoding"} {
--			delHeader(k)
--		}
--	} else {
+-	if bodyAllowedForStatus(code) {
 -		// If no content type, apply sniffing algorithm to body.
 -		_, haveType := header["Content-Type"]
 -		if !haveType {
 -			setHeader.contentType = DetectContentType(p)
 -		}
+-	} else {
+-		for _, k := range suppressedHeaders(code) {
+-			delHeader(k)
+-		}
 -	}
 -
 -	if _, ok := header["Date"]; !ok {
@@ -3865,16 +3947,10 @@
 -		// Expect 100 Continue support
 -		req := w.req
 -		if req.expectsContinue() {
--			if req.ProtoAtLeast(1, 1) {
+-			if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
 -				// Wrap the Body reader with one that replies on the connection
 -				req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
 -			}
--			if req.ContentLength == 0 {
--				w.Header().Set("Connection", "close")
--				w.WriteHeader(StatusBadRequest)
--				w.finishRequest()
--				break
--			}
 -			req.Header.Del("Expect")
 -		} else if req.Header.get("Expect") != "" {
 -			w.sendExpectationFailed()
@@ -4685,11 +4761,11 @@
 -}
 +)
  
- // eofReader is a non-nil io.ReadCloser that always returns EOF.
- // It embeds a *strings.Reader so it still has a WriteTo method
-@@ -1992,28 +25,6 @@
- 	ioutil.NopCloser(nil),
- }
+ type eofReaderWithWriteTo struct{}
+ 
+@@ -1991,28 +31,6 @@
+ // Verify that an io.Copy from an eofReader won't require a buffer.
+ var _ io.WriterTo = eofReader
  
 -// initNPNRequest is an HTTP handler that initializes certain
 -// uninitialized fields in its *Request. Such partially-initialized
 
=== modified file 'http13client/_patches/fix_code.patch'
--- http13client/_patches/fix_code.patch	2014-03-19 23:13:58 +0000
+++ http13client/_patches/fix_code.patch	2014-07-02 13:12:36 +0000
@@ -1,6 +1,6 @@
 === modified file 'http13client/client.go'
---- http13client/client.go	2014-03-19 20:20:19 +0000
-+++ http13client/client.go	2014-03-19 22:27:37 +0000
+--- http13client/client.go	2014-06-20 11:00:47 +0000
++++ http13client/client.go	2014-06-20 12:05:53 +0000
 @@ -17,6 +17,7 @@
  	"io/ioutil"
  	"log"
@@ -18,7 +18,7 @@
  
  	// Timeout specifies a time limit for requests made by this
  	// Client. The timeout includes connection time, any
-@@ -177,7 +178,7 @@
+@@ -184,7 +185,7 @@
  	// Headers, leaving it uninitialized.  We guarantee to the
  	// Transport that this has been initialized, though.
  	if req.Header == nil {
@@ -27,7 +27,7 @@
  	}
  
  	if u := req.URL.User; u != nil {
-@@ -308,7 +309,7 @@
+@@ -316,7 +317,7 @@
  			if ireq.Method == "POST" || ireq.Method == "PUT" {
  				nreq.Method = "GET"
  			}
@@ -38,8 +38,8 @@
  				break
 
 === modified file 'http13client/cookie.go'
---- http13client/cookie.go	2014-03-19 20:20:19 +0000
-+++ http13client/cookie.go	2014-03-19 22:27:37 +0000
+--- http13client/cookie.go	2014-06-20 11:00:47 +0000
++++ http13client/cookie.go	2014-06-20 12:05:53 +0000
 @@ -5,10 +5,9 @@
  package http
  
@@ -94,7 +94,7 @@
  			Name:  name,
  			Value: value,
  			Raw:   line,
-@@ -129,59 +108,12 @@
+@@ -125,59 +104,12 @@
  	return cookies
  }
  
@@ -156,7 +156,7 @@
  	lines, ok := h["Cookie"]
  	if !ok {
  		return cookies
-@@ -213,7 +145,7 @@
+@@ -209,7 +141,7 @@
  			if !success {
  				continue
  			}
@@ -167,8 +167,8 @@
  	}
 
 === modified file 'http13client/header.go'
---- http13client/header.go	2014-03-19 20:20:19 +0000
-+++ http13client/header.go	2014-03-19 22:27:37 +0000
+--- http13client/header.go	2014-06-20 11:00:47 +0000
++++ http13client/header.go	2014-06-20 12:00:22 +0000
 @@ -5,176 +5,9 @@
  package http
  
@@ -348,8 +348,8 @@
  // token must be all lowercase.
 
 === modified file 'http13client/request.go'
---- http13client/request.go	2014-03-19 20:20:19 +0000
-+++ http13client/request.go	2014-03-19 22:27:37 +0000
+--- http13client/request.go	2014-06-20 11:00:47 +0000
++++ http13client/request.go	2014-06-20 12:05:53 +0000
 @@ -16,6 +16,7 @@
  	"io/ioutil"
  	"mime"
@@ -358,25 +358,25 @@
  	"net/textproto"
  	"net/url"
  	"strconv"
-@@ -103,7 +104,7 @@
- 	// The request parser implements this by canonicalizing the
- 	// name, making the first character and any characters
- 	// following a hyphen uppercase and the rest lowercase.
+@@ -121,7 +122,7 @@
+ 	// added and may override values in Header.
+ 	//
+ 	// See the documentation for the Request.Write method.
 -	Header Header
 +	Header http.Header
  
  	// Body is the request's body.
  	//
-@@ -164,7 +165,7 @@
- 	// For server requests, Trailer is only populated after Body has been
- 	// closed or fully consumed.
- 	// Trailer support is only partially complete.
+@@ -199,7 +200,7 @@
+ 	// not mutate Trailer.
+ 	//
+ 	// Few HTTP clients, servers, or proxies support HTTP trailers.
 -	Trailer Header
 +	Trailer http.Header
  
  	// RemoteAddr allows HTTP servers and other software to record
  	// the network address that sent the request, usually for
-@@ -204,7 +205,7 @@
+@@ -239,7 +240,7 @@
  }
  
  // Cookies parses and returns the HTTP cookies sent with the request.
@@ -385,7 +385,7 @@
  	return readCookies(r.Header, "")
  }
  
-@@ -212,7 +213,7 @@
+@@ -247,7 +248,7 @@
  
  // Cookie returns the named cookie provided in the request or
  // ErrNoCookie if not found.
@@ -394,7 +394,7 @@
  	for _, c := range readCookies(r.Header, name) {
  		return c, nil
  	}
-@@ -223,7 +224,7 @@
+@@ -258,7 +259,7 @@
  // AddCookie does not attach more than one Cookie header field.  That
  // means all cookies, if any, are written into the same line,
  // separated by semicolon.
@@ -403,7 +403,7 @@
  	s := fmt.Sprintf("%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value))
  	if c := r.Header.Get("Cookie"); c != "" {
  		r.Header.Set("Cookie", c+"; "+s)
-@@ -326,7 +327,7 @@
+@@ -361,7 +362,7 @@
  }
  
  // extraHeaders may be nil
@@ -412,7 +412,7 @@
  	host := req.Host
  	if host == "" {
  		if req.URL == nil {
-@@ -456,7 +457,7 @@
+@@ -490,7 +491,7 @@
  		Proto:      "HTTP/1.1",
  		ProtoMajor: 1,
  		ProtoMinor: 1,
@@ -421,7 +421,7 @@
  		Body:       rc,
  		Host:       u.Host,
  	}
-@@ -571,7 +572,7 @@
+@@ -605,7 +606,7 @@
  	if err != nil {
  		return nil, err
  	}
@@ -430,7 +430,7 @@
  
  	// RFC2616: Must treat
  	//	GET /index.html HTTP/1.1
-@@ -582,7 +583,7 @@
+@@ -616,7 +617,7 @@
  	// the same.  In the second case, any Host line is ignored.
  	req.Host = req.URL.Host
  	if req.Host == "" {
@@ -439,7 +439,7 @@
  	}
  	delete(req.Header, "Host")
  
-@@ -630,12 +631,12 @@
+@@ -638,12 +639,12 @@
  //
  // MaxBytesReader prevents clients from accidentally or maliciously
  // sending a large request and wasting server resources.
@@ -454,7 +454,7 @@
  	r       io.ReadCloser // underlying reader
  	n       int64         // max bytes remaining
  	stopped bool
-@@ -645,9 +646,6 @@
+@@ -653,9 +654,6 @@
  	if l.n <= 0 {
  		if !l.stopped {
  			l.stopped = true
@@ -464,7 +464,7 @@
  		}
  		return 0, errors.New("http: request body too large")
  	}
-@@ -852,16 +850,16 @@
+@@ -858,18 +856,18 @@
  }
  
  func (r *Request) expectsContinue() bool {
@@ -484,11 +484,13 @@
 -	return hasToken(r.Header.get("Connection"), "close")
 +	return hasToken(r.Header.Get("Connection"), "close")
  }
+ 
+ func (r *Request) closeBody() {
 
 === modified file 'http13client/response.go'
---- http13client/response.go	2014-03-19 20:20:19 +0000
-+++ http13client/response.go	2014-03-19 22:27:37 +0000
-@@ -11,6 +11,7 @@
+--- http13client/response.go	2014-06-20 11:00:47 +0000
++++ http13client/response.go	2014-06-20 12:05:53 +0000
+@@ -12,6 +12,7 @@
  	"crypto/tls"
  	"errors"
  	"io"
@@ -496,7 +498,7 @@
  	"net/textproto"
  	"net/url"
  	"strconv"
-@@ -40,7 +41,7 @@
+@@ -41,7 +42,7 @@
  	// omitted from Header.
  	//
  	// Keys in the map are canonicalized (see CanonicalHeaderKey).
@@ -505,7 +507,7 @@
  
  	// Body represents the response body.
  	//
-@@ -69,7 +70,7 @@
+@@ -71,7 +72,7 @@
  
  	// Trailer maps trailer keys to values, in the same
  	// format as the header.
@@ -514,7 +516,7 @@
  
  	// The Request that was sent to obtain this Response.
  	// Request's Body is nil (having already been consumed).
-@@ -84,7 +85,7 @@
+@@ -86,7 +87,7 @@
  }
  
  // Cookies parses and returns the cookies set in the Set-Cookie headers.
@@ -523,7 +525,7 @@
  	return readSetCookies(r.Header)
  }
  
-@@ -153,7 +154,7 @@
+@@ -155,7 +156,7 @@
  		}
  		return nil, err
  	}
@@ -532,7 +534,7 @@
  
  	fixPragmaCacheControl(resp.Header)
  
-@@ -169,7 +170,7 @@
+@@ -171,7 +172,7 @@
  //	Pragma: no-cache
  // like
  //	Cache-Control: no-cache
@@ -543,17 +545,17 @@
  			header["Cache-Control"] = []string{"no-cache"}
 
 === modified file 'http13client/transfer.go'
---- http13client/transfer.go	2014-03-19 20:20:19 +0000
-+++ http13client/transfer.go	2014-03-19 22:27:37 +0000
+--- http13client/transfer.go	2014-06-20 11:00:47 +0000
++++ http13client/transfer.go	2014-06-20 12:05:53 +0000
 @@ -11,6 +11,7 @@
  	"fmt"
  	"io"
  	"io/ioutil"
 +	"net/http"
  	"net/textproto"
+ 	"sort"
  	"strconv"
- 	"strings"
-@@ -36,7 +37,7 @@
+@@ -37,7 +38,7 @@
  	ContentLength    int64 // -1 means unknown, 0 means exactly none
  	Close            bool
  	TransferEncoding []string
@@ -562,16 +564,16 @@
  }
  
  func newTransferWriter(r interface{}) (t *transferWriter, err error) {
-@@ -174,7 +175,7 @@
- 		io.WriteString(w, "Trailer: ")
- 		needComma := false
+@@ -171,7 +172,7 @@
+ 	if t.Trailer != nil {
+ 		keys := make([]string, 0, len(t.Trailer))
  		for k := range t.Trailer {
 -			k = CanonicalHeaderKey(k)
 +			k = http.CanonicalHeaderKey(k)
  			switch k {
  			case "Transfer-Encoding", "Trailer", "Content-Length":
  				return &badStringError{"invalid Trailer key", k}
-@@ -237,7 +238,7 @@
+@@ -243,7 +244,7 @@
  
  type transferReader struct {
  	// Input
@@ -580,7 +582,7 @@
  	StatusCode    int
  	RequestMethod string
  	ProtoMajor    int
-@@ -247,7 +248,7 @@
+@@ -253,7 +254,7 @@
  	ContentLength    int64
  	TransferEncoding []string
  	Close            bool
@@ -589,7 +591,7 @@
  }
  
  // bodyAllowedForStatus reports whether a given response status code
-@@ -308,7 +309,7 @@
+@@ -330,7 +331,7 @@
  		return err
  	}
  	if isResponse && t.RequestMethod == "HEAD" {
@@ -598,7 +600,7 @@
  			return err
  		} else {
  			t.ContentLength = n
-@@ -386,7 +387,7 @@
+@@ -408,7 +409,7 @@
  func isIdentity(te []string) bool { return len(te) == 1 && te[0] == "identity" }
  
  // Sanitize transfer encoding
@@ -607,7 +609,7 @@
  	raw, present := header["Transfer-Encoding"]
  	if !present {
  		return nil, nil
-@@ -429,7 +430,7 @@
+@@ -451,7 +452,7 @@
  // Determine the expected body length, using RFC 2616 Section 4.4. This
  // function is not a method, because ultimately it should be shared by
  // ReadResponse and ReadRequest.
@@ -616,7 +618,7 @@
  
  	// Logic based on response type or status
  	if noBodyExpected(requestMethod) {
-@@ -449,7 +450,7 @@
+@@ -471,7 +472,7 @@
  	}
  
  	// Logic based on Content-Length
@@ -625,7 +627,7 @@
  	if cl != "" {
  		n, err := parseContentLength(cl)
  		if err != nil {
-@@ -475,18 +476,18 @@
+@@ -497,18 +498,18 @@
  // Determine whether to hang up after sending a request and body, or
  // receiving a response and body
  // 'header' is the request headers
@@ -647,7 +649,7 @@
  			header.Del("Connection")
  			return true
  		}
-@@ -495,17 +496,17 @@
+@@ -517,17 +518,17 @@
  }
  
  // Parse the trailer header
@@ -669,22 +671,28 @@
  		switch key {
  		case "Transfer-Encoding", "Trailer", "Content-Length":
  			return nil, &badStringError{"bad trailer key", key}
-@@ -642,9 +643,9 @@
+@@ -664,14 +665,14 @@
  	}
  	switch rr := b.hdr.(type) {
  	case *Request:
--		rr.Trailer = Header(hdr)
-+		rr.Trailer = http.Header(hdr)
+-		mergeSetHeader(&rr.Trailer, Header(hdr))
++		mergeSetHeader(&rr.Trailer, http.Header(hdr))
  	case *Response:
--		rr.Trailer = Header(hdr)
-+		rr.Trailer = http.Header(hdr)
+-		mergeSetHeader(&rr.Trailer, Header(hdr))
++		mergeSetHeader(&rr.Trailer, http.Header(hdr))
  	}
  	return nil
  }
+ 
+-func mergeSetHeader(dst *Header, src Header) {
++func mergeSetHeader(dst *http.Header, src http.Header) {
+ 	if *dst == nil {
+ 		*dst = src
+ 		return
 
 === modified file 'http13client/transport.go'
---- http13client/transport.go	2014-03-19 20:20:19 +0000
-+++ http13client/transport.go	2014-03-19 22:27:37 +0000
+--- http13client/transport.go	2014-06-20 11:00:47 +0000
++++ http13client/transport.go	2014-06-20 12:05:53 +0000
 @@ -18,6 +18,7 @@
  	"io"
  	"log"
@@ -693,7 +701,7 @@
  	"net/url"
  	"os"
  	"strings"
-@@ -144,12 +145,12 @@
+@@ -147,12 +148,12 @@
  // optional extra headers to write.
  type transportRequest struct {
  	*Request        // original request, not to be mutated
@@ -709,7 +717,7 @@
  	}
  	return tr.extra
  }
-@@ -512,7 +513,7 @@
+@@ -519,7 +520,7 @@
  	case cm.targetScheme == "http":
  		pconn.isProxy = true
  		if pa != "" {
@@ -718,7 +726,7 @@
  				h.Set("Proxy-Authorization", pa)
  			}
  		}
-@@ -521,7 +522,7 @@
+@@ -528,7 +529,7 @@
  			Method: "CONNECT",
  			URL:    &url.URL{Opaque: cm.targetAddr},
  			Host:   cm.targetAddr,
@@ -727,7 +735,7 @@
  		}
  		if pa != "" {
  			connectReq.Header.Set("Proxy-Authorization", pa)
-@@ -735,7 +736,7 @@
+@@ -748,7 +749,7 @@
  	// mutateHeaderFunc is an optional func to modify extra
  	// headers on each outbound request before it's written. (the
  	// original Request given to RoundTrip is not modified)
@@ -735,5 +743,5 @@
 +	mutateHeaderFunc func(http.Header)
  }
  
- func (pc *persistConn) isBroken() bool {
+ // isBroken reports whether this connection is in a known broken state.
 
 
=== modified file 'http13client/_patches/fix_status.patch'
--- http13client/_patches/fix_status.patch	2014-03-19 23:43:25 +0000
+++ http13client/_patches/fix_status.patch	2014-07-02 13:12:36 +0000
@@ -1,7 +1,7 @@
 === modified file 'http13client/client.go'
---- http13client/client.go	2014-03-19 23:13:58 +0000
-+++ http13client/client.go	2014-03-19 23:38:11 +0000
-@@ -210,7 +210,7 @@
+--- http13client/client.go	2014-06-20 12:46:25 +0000
++++ http13client/client.go	2014-06-20 12:46:45 +0000
+@@ -217,7 +217,7 @@
  // automatically redirect.
  func shouldRedirectGet(statusCode int) bool {
  	switch statusCode {
@@ -10,7 +10,7 @@
  		return true
  	}
  	return false
-@@ -220,7 +220,7 @@
+@@ -227,7 +227,7 @@
  // automatically redirect.
  func shouldRedirectPost(statusCode int) bool {
  	switch statusCode {
@@ -21,9 +21,9 @@
  	return false
 
 === modified file 'http13client/client_test.go'
---- http13client/client_test.go	2014-03-19 23:13:58 +0000
-+++ http13client/client_test.go	2014-03-19 23:39:48 +0000
-@@ -202,7 +202,7 @@
+--- http13client/client_test.go	2014-06-20 12:46:25 +0000
++++ http13client/client_test.go	2014-06-20 12:46:45 +0000
+@@ -204,7 +204,7 @@
  			}
  		}
  		if n < 15 {
@@ -32,7 +32,7 @@
  			return
  		}
  		fmt.Fprintf(w, "n=%d", n)
-@@ -324,7 +324,7 @@
+@@ -326,7 +326,7 @@
  	}
  	if r.URL.Path == "/" {
  		http.SetCookie(w, expectedCookies[1])
@@ -41,7 +41,7 @@
  	} else {
  		http.SetCookie(w, expectedCookies[2])
  		w.Write([]byte("hello"))
-@@ -783,7 +783,7 @@
+@@ -785,7 +785,7 @@
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		if r.URL.Path == "/" {
  			sawRoot <- true
@@ -50,7 +50,7 @@
  			return
  		}
  		if r.URL.Path == "/slow" {
-@@ -844,7 +844,7 @@
+@@ -846,7 +846,7 @@
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  		saw <- r.RemoteAddr
  		if r.URL.Path == "/" {
@@ -61,9 +61,9 @@
  	defer ts.Close()
 
 === modified file 'http13client/request_test.go'
---- http13client/request_test.go	2014-03-19 23:13:58 +0000
-+++ http13client/request_test.go	2014-03-19 23:40:12 +0000
-@@ -164,11 +164,11 @@
+--- http13client/request_test.go	2014-06-20 12:46:25 +0000
++++ http13client/request_test.go	2014-06-20 12:46:45 +0000
+@@ -182,11 +182,11 @@
  		switch r.URL.Path {
  		case "/":
  			w.Header().Set("Location", "/foo/")
@@ -79,9 +79,9 @@
  	defer ts.Close()
 
 === modified file 'http13client/response.go'
---- http13client/response.go	2014-03-19 23:13:58 +0000
-+++ http13client/response.go	2014-03-19 23:38:56 +0000
-@@ -204,9 +204,8 @@
+--- http13client/response.go	2014-06-20 12:46:25 +0000
++++ http13client/response.go	2014-06-20 12:46:45 +0000
+@@ -205,9 +205,8 @@
  	// Status line
  	text := r.Status
  	if text == "" {
@@ -94,10 +94,23 @@
  		}
  	}
 
+=== modified file 'http13client/responsewrite_test.go'
+--- http13client/responsewrite_test.go	2014-06-20 12:46:25 +0000
++++ http13client/responsewrite_test.go	2014-06-20 12:47:05 +0000
+@@ -197,7 +197,7 @@
+ 		// there were two.
+ 		{
+ 			Response{
+-				StatusCode:       StatusOK,
++				StatusCode:       http.StatusOK,
+ 				ProtoMajor:       1,
+ 				ProtoMinor:       1,
+ 				Request:          &Request{Method: "POST"},
+
 === modified file 'http13client/transport_test.go'
---- http13client/transport_test.go	2014-03-19 23:13:58 +0000
-+++ http13client/transport_test.go	2014-03-19 23:40:39 +0000
-@@ -968,7 +968,7 @@
+--- http13client/transport_test.go	2014-06-20 12:46:25 +0000
++++ http13client/transport_test.go	2014-06-20 12:46:45 +0000
+@@ -1004,7 +1004,7 @@
  	defer afterTest(t)
  	const deniedMsg = "sorry, denied."
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -106,7 +119,7 @@
  	}))
  	defer ts.Close()
  	tr := &Transport{}
-@@ -992,7 +992,7 @@
+@@ -1028,7 +1028,7 @@
  func TestChunkedNoContent(t *testing.T) {
  	defer afterTest(t)
  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
=== modified file 'http13client/_patches/fix_tests.patch'
--- http13client/_patches/fix_tests.patch	2014-03-19 23:13:58 +0000
+++ http13client/_patches/fix_tests.patch	2014-07-02 13:12:36 +0000
@@ -1,6 +1,6 @@
 === modified file 'http13client/client_test.go'
---- http13client/client_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/client_test.go	2014-03-19 22:27:37 +0000
+--- http13client/client_test.go	2014-06-20 11:00:47 +0000
++++ http13client/client_test.go	2014-06-20 12:05:53 +0000
 @@ -15,8 +15,8 @@
  	"fmt"
  	"io"
@@ -11,7 +11,7 @@
  	. "launchpad.net/ubuntu-push/http13client"
  	"net/http/httptest"
  	"net/url"
-@@ -27,7 +27,7 @@
+@@ -29,7 +29,7 @@
  	"time"
  )
  
@@ -20,7 +20,7 @@
  	w.Header().Set("Last-Modified", "sometime")
  	fmt.Fprintf(w, "User-agent: go\nDisallow: /something/")
  })
-@@ -193,7 +193,7 @@
+@@ -195,7 +195,7 @@
  func TestClientRedirects(t *testing.T) {
  	defer afterTest(t)
  	var ts *httptest.Server
@@ -29,7 +29,7 @@
  		n, _ := strconv.Atoi(r.FormValue("n"))
  		// Test Referer header. (7 is arbitrary position to test at)
  		if n == 7 {
-@@ -202,7 +202,7 @@
+@@ -204,7 +204,7 @@
  			}
  		}
  		if n < 15 {
@@ -38,7 +38,7 @@
  			return
  		}
  		fmt.Fprintf(w, "n=%d", n)
-@@ -271,7 +271,7 @@
+@@ -273,7 +273,7 @@
  		bytes.Buffer
  	}
  	var ts *httptest.Server
@@ -47,7 +47,7 @@
  		log.Lock()
  		fmt.Fprintf(&log.Buffer, "%s %s ", r.Method, r.RequestURI)
  		log.Unlock()
-@@ -312,21 +312,21 @@
+@@ -314,21 +314,21 @@
  	}
  }
  
@@ -75,7 +75,7 @@
  		w.Write([]byte("hello"))
  	}
  })
-@@ -334,7 +334,7 @@
+@@ -336,7 +336,7 @@
  func TestClientSendsCookieFromJar(t *testing.T) {
  	tr := &recordingTransport{}
  	client := &Client{Transport: tr}
@@ -84,7 +84,7 @@
  	us := "http://dummy.faketld/"
  	u, _ := url.Parse(us)
  	client.Jar.SetCookies(u, expectedCookies)
-@@ -364,19 +364,19 @@
+@@ -366,19 +366,19 @@
  // scope of all cookies.
  type TestJar struct {
  	m      sync.Mutex
@@ -108,7 +108,7 @@
  	j.m.Lock()
  	defer j.m.Unlock()
  	return j.perURL[u.Host]
-@@ -391,7 +391,7 @@
+@@ -393,7 +393,7 @@
  		Jar: new(TestJar),
  	}
  	u, _ := url.Parse(ts.URL)
@@ -117,7 +117,7 @@
  	resp, err := c.Get(ts.URL)
  	if err != nil {
  		t.Fatalf("Get: %v", err)
-@@ -400,7 +400,7 @@
+@@ -402,7 +402,7 @@
  	matchReturnedCookies(t, expectedCookies, resp.Cookies())
  }
  
@@ -126,7 +126,7 @@
  	if len(given) != len(expected) {
  		t.Logf("Received cookies: %v", given)
  		t.Errorf("Expected %d cookies, got %d", len(expected), len(given))
-@@ -421,14 +421,14 @@
+@@ -423,14 +423,14 @@
  
  func TestJarCalls(t *testing.T) {
  	defer afterTest(t)
@@ -144,7 +144,7 @@
  		}
  	}))
  	defer ts.Close()
-@@ -468,11 +468,11 @@
+@@ -470,11 +470,11 @@
  	log bytes.Buffer
  }
  
@@ -158,7 +158,7 @@
  	j.logf("Cookies(%q)\n", u)
  	return nil
  }
-@@ -486,11 +486,11 @@
+@@ -488,11 +488,11 @@
  func TestStreamingGet(t *testing.T) {
  	defer afterTest(t)
  	say := make(chan string)
@@ -173,7 +173,7 @@
  		}
  	}))
  	defer ts.Close()
-@@ -536,7 +536,7 @@
+@@ -538,7 +538,7 @@
  // don't send a TCP packet per line of the http request + body.
  func TestClientWrites(t *testing.T) {
  	defer afterTest(t)
@@ -182,7 +182,7 @@
  	}))
  	defer ts.Close()
  
-@@ -568,46 +568,6 @@
+@@ -570,46 +570,6 @@
  	}
  }
  
@@ -229,7 +229,7 @@
  func TestClientErrorWithRequestURI(t *testing.T) {
  	defer afterTest(t)
  	req, _ := NewRequest("GET", "http://localhost:1234/", nil)
-@@ -639,7 +599,7 @@
+@@ -641,7 +601,7 @@
  
  func TestClientWithCorrectTLSServerName(t *testing.T) {
  	defer afterTest(t)
@@ -238,7 +238,7 @@
  		if r.TLS.ServerName != "127.0.0.1" {
  			t.Errorf("expected client to set ServerName 127.0.0.1, got: %q", r.TLS.ServerName)
  		}
-@@ -652,33 +612,6 @@
+@@ -654,33 +614,6 @@
  	}
  }
  
@@ -272,7 +272,7 @@
  // Test for golang.org/issue/5829; the Transport should respect TLSClientConfig.ServerName
  // when not empty.
  //
-@@ -690,7 +623,7 @@
+@@ -692,7 +625,7 @@
  // The httptest.Server has a cert with "example.com" as its name.
  func TestTransportUsesTLSConfigServerName(t *testing.T) {
  	defer afterTest(t)
@@ -281,7 +281,7 @@
  		w.Write([]byte("Hello"))
  	}))
  	defer ts.Close()
-@@ -711,7 +644,7 @@
+@@ -713,7 +646,7 @@
  
  func TestResponseSetsTLSConnectionState(t *testing.T) {
  	defer afterTest(t)
@@ -290,7 +290,7 @@
  		w.Write([]byte("Hello"))
  	}))
  	defer ts.Close()
-@@ -739,7 +672,7 @@
+@@ -741,7 +674,7 @@
  // Verify Response.ContentLength is populated. http://golang.org/issue/4126
  func TestClientHeadContentLength(t *testing.T) {
  	defer afterTest(t)
@@ -299,7 +299,7 @@
  		if v := r.FormValue("cl"); v != "" {
  			w.Header().Set("Content-Length", v)
  		}
-@@ -775,7 +708,7 @@
+@@ -777,7 +710,7 @@
  func TestEmptyPasswordAuth(t *testing.T) {
  	defer afterTest(t)
  	gopher := "gopher"
@@ -308,7 +308,7 @@
  		auth := r.Header.Get("Authorization")
  		if strings.HasPrefix(auth, "Basic ") {
  			encoded := auth[6:]
-@@ -847,15 +780,15 @@
+@@ -849,15 +782,15 @@
  	defer afterTest(t)
  	sawRoot := make(chan bool, 1)
  	sawSlow := make(chan bool, 1)
@@ -327,7 +327,7 @@
  			sawSlow <- true
  			time.Sleep(2 * time.Second)
  			return
-@@ -908,10 +841,10 @@
+@@ -910,10 +843,10 @@
  func TestClientRedirectEatsBody(t *testing.T) {
  	defer afterTest(t)
  	saw := make(chan string, 2)
@@ -340,233 +340,50 @@
  		}
  	}))
  	defer ts.Close()
-
-=== modified file 'http13client/cookie_test.go'
---- http13client/cookie_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/cookie_test.go	2014-03-19 22:27:37 +0000
-@@ -9,6 +9,7 @@
- 	"encoding/json"
- 	"fmt"
- 	"log"
-+	"net/http"
- 	"os"
- 	"reflect"
- 	"strings"
-@@ -17,39 +18,39 @@
- )
- 
- var writeSetCookiesTests = []struct {
--	Cookie *Cookie
-+	Cookie *http.Cookie
- 	Raw    string
- }{
- 	{
--		&Cookie{Name: "cookie-1", Value: "v$1"},
-+		&http.Cookie{Name: "cookie-1", Value: "v$1"},
- 		"cookie-1=v$1",
- 	},
- 	{
--		&Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600},
-+		&http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600},
- 		"cookie-2=two; Max-Age=3600",
- 	},
- 	{
--		&Cookie{Name: "cookie-3", Value: "three", Domain: ".example.com"},
-+		&http.Cookie{Name: "cookie-3", Value: "three", Domain: ".example.com"},
- 		"cookie-3=three; Domain=example.com",
- 	},
- 	{
--		&Cookie{Name: "cookie-4", Value: "four", Path: "/restricted/"},
-+		&http.Cookie{Name: "cookie-4", Value: "four", Path: "/restricted/"},
- 		"cookie-4=four; Path=/restricted/",
- 	},
- 	{
--		&Cookie{Name: "cookie-5", Value: "five", Domain: "wrong;bad.abc"},
-+		&http.Cookie{Name: "cookie-5", Value: "five", Domain: "wrong;bad.abc"},
- 		"cookie-5=five",
- 	},
- 	{
--		&Cookie{Name: "cookie-6", Value: "six", Domain: "bad-.abc"},
-+		&http.Cookie{Name: "cookie-6", Value: "six", Domain: "bad-.abc"},
- 		"cookie-6=six",
- 	},
- 	{
--		&Cookie{Name: "cookie-7", Value: "seven", Domain: "127.0.0.1"},
-+		&http.Cookie{Name: "cookie-7", Value: "seven", Domain: "127.0.0.1"},
- 		"cookie-7=seven; Domain=127.0.0.1",
- 	},
- 	{
--		&Cookie{Name: "cookie-8", Value: "eight", Domain: "::1"},
-+		&http.Cookie{Name: "cookie-8", Value: "eight", Domain: "::1"},
- 		"cookie-8=eight",
- 	},
- }
-@@ -71,10 +72,10 @@
- 	}
- }
- 
--type headerOnlyResponseWriter Header
-+type headerOnlyResponseWriter http.Header
- 
--func (ho headerOnlyResponseWriter) Header() Header {
--	return Header(ho)
-+func (ho headerOnlyResponseWriter) Header() http.Header {
-+	return http.Header(ho)
- }
- 
- func (ho headerOnlyResponseWriter) Write([]byte) (int, error) {
-@@ -86,9 +87,9 @@
- }
- 
- func TestSetCookie(t *testing.T) {
--	m := make(Header)
--	SetCookie(headerOnlyResponseWriter(m), &Cookie{Name: "cookie-1", Value: "one", Path: "/restricted/"})
--	SetCookie(headerOnlyResponseWriter(m), &Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600})
-+	m := make(http.Header)
-+	http.SetCookie(headerOnlyResponseWriter(m), &http.Cookie{Name: "cookie-1", Value: "one", Path: "/restricted/"})
-+	http.SetCookie(headerOnlyResponseWriter(m), &http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600})
- 	if l := len(m["Set-Cookie"]); l != 2 {
- 		t.Fatalf("expected %d cookies, got %d", 2, l)
- 	}
-@@ -101,19 +102,19 @@
- }
- 
- var addCookieTests = []struct {
--	Cookies []*Cookie
-+	Cookies []*http.Cookie
- 	Raw     string
- }{
- 	{
--		[]*Cookie{},
-+		[]*http.Cookie{},
- 		"",
- 	},
- 	{
--		[]*Cookie{{Name: "cookie-1", Value: "v$1"}},
-+		[]*http.Cookie{{Name: "cookie-1", Value: "v$1"}},
- 		"cookie-1=v$1",
- 	},
- 	{
--		[]*Cookie{
-+		[]*http.Cookie{
- 			{Name: "cookie-1", Value: "v$1"},
- 			{Name: "cookie-2", Value: "v$2"},
- 			{Name: "cookie-3", Value: "v$3"},
-@@ -136,16 +137,16 @@
- }
- 
- var readSetCookiesTests = []struct {
--	Header  Header
--	Cookies []*Cookie
-+	Header  http.Header
-+	Cookies []*http.Cookie
- }{
- 	{
--		Header{"Set-Cookie": {"Cookie-1=v$1"}},
--		[]*Cookie{{Name: "Cookie-1", Value: "v$1", Raw: "Cookie-1=v$1"}},
-+		http.Header{"Set-Cookie": {"Cookie-1=v$1"}},
-+		[]*http.Cookie{{Name: "Cookie-1", Value: "v$1", Raw: "Cookie-1=v$1"}},
- 	},
- 	{
--		Header{"Set-Cookie": {"NID=99=YsDT5i3E-CXax-; expires=Wed, 23-Nov-2011 01:05:03 GMT; path=/; domain=.google.ch; HttpOnly"}},
--		[]*Cookie{{
-+		http.Header{"Set-Cookie": {"NID=99=YsDT5i3E-CXax-; expires=Wed, 23-Nov-2011 01:05:03 GMT; path=/; domain=.google.ch; HttpOnly"}},
-+		[]*http.Cookie{{
- 			Name:       "NID",
- 			Value:      "99=YsDT5i3E-CXax-",
- 			Path:       "/",
-@@ -157,8 +158,8 @@
- 		}},
- 	},
- 	{
--		Header{"Set-Cookie": {".ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}},
--		[]*Cookie{{
-+		http.Header{"Set-Cookie": {".ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}},
-+		[]*http.Cookie{{
- 			Name:       ".ASPXAUTH",
- 			Value:      "7E3AA",
- 			Path:       "/",
-@@ -169,8 +170,8 @@
- 		}},
- 	},
- 	{
--		Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly"}},
--		[]*Cookie{{
-+		http.Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly"}},
-+		[]*http.Cookie{{
- 			Name:     "ASP.NET_SessionId",
- 			Value:    "foo",
- 			Path:     "/",
-@@ -207,37 +208,37 @@
- }
- 
- var readCookiesTests = []struct {
--	Header  Header
-+	Header  http.Header
- 	Filter  string
--	Cookies []*Cookie
-+	Cookies []*http.Cookie
- }{
- 	{
--		Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
--		"",
--		[]*Cookie{
--			{Name: "Cookie-1", Value: "v$1"},
--			{Name: "c2", Value: "v2"},
--		},
--	},
--	{
--		Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
--		"c2",
--		[]*Cookie{
--			{Name: "c2", Value: "v2"},
--		},
--	},
--	{
--		Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
--		"",
--		[]*Cookie{
--			{Name: "Cookie-1", Value: "v$1"},
--			{Name: "c2", Value: "v2"},
--		},
--	},
--	{
--		Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
--		"c2",
--		[]*Cookie{
-+		http.Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
-+		"",
-+		[]*http.Cookie{
-+			{Name: "Cookie-1", Value: "v$1"},
-+			{Name: "c2", Value: "v2"},
-+		},
-+	},
-+	{
-+		http.Header{"Cookie": {"Cookie-1=v$1", "c2=v2"}},
-+		"c2",
-+		[]*http.Cookie{
-+			{Name: "c2", Value: "v2"},
-+		},
-+	},
-+	{
-+		http.Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
-+		"",
-+		[]*http.Cookie{
-+			{Name: "Cookie-1", Value: "v$1"},
-+			{Name: "c2", Value: "v2"},
-+		},
-+	},
-+	{
-+		http.Header{"Cookie": {"Cookie-1=v$1; c2=v2"}},
-+		"c2",
-+		[]*http.Cookie{
- 			{Name: "c2", Value: "v2"},
- 		},
- 	},
+@@ -957,7 +890,7 @@
+ 
+ func TestClientTrailers(t *testing.T) {
+ 	defer afterTest(t)
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		w.Header().Set("Connection", "close")
+ 		w.Header().Set("Trailer", "Server-Trailer-A, Server-Trailer-B")
+ 		w.Header().Add("Trailer", "Server-Trailer-C")
+@@ -992,9 +925,9 @@
+ 		// trailers to be sent, if and only if they were
+ 		// previously declared with w.Header().Set("Trailer",
+ 		// ..keys..)
+-		w.(Flusher).Flush()
+-		conn, buf, _ := w.(Hijacker).Hijack()
+-		t := Header{}
++		w.(http.Flusher).Flush()
++		conn, buf, _ := w.(http.Hijacker).Hijack()
++		t := http.Header{}
+ 		t.Set("Server-Trailer-A", "valuea")
+ 		t.Set("Server-Trailer-C", "valuec") // skipping B
+ 		buf.WriteString("0\r\n")            // eof
+@@ -1015,7 +948,7 @@
+ 			req.Trailer["Client-Trailer-B"] = []string{"valueb"}
+ 		}),
+ 	))
+-	req.Trailer = Header{
++	req.Trailer = http.Header{
+ 		"Client-Trailer-A": nil, //  to be set later
+ 		"Client-Trailer-B": nil, //  to be set later
+ 	}
+@@ -1027,7 +960,7 @@
+ 	if err := wantBody(res, err, "decl: [Client-Trailer-A Client-Trailer-B], vals: valuea, valueb"); err != nil {
+ 		t.Error(err)
+ 	}
+-	want := Header{
++	want := http.Header{
+ 		"Server-Trailer-A": []string{"valuea"},
+ 		"Server-Trailer-B": nil,
+ 		"Server-Trailer-C": []string{"valuec"},
 
 === modified file 'http13client/export_test.go'
---- http13client/export_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/export_test.go	2014-03-19 22:27:37 +0000
+--- http13client/export_test.go	2014-06-20 11:00:47 +0000
++++ http13client/export_test.go	2014-06-20 12:00:22 +0000
 @@ -9,15 +9,12 @@
  
  import (
@@ -599,8 +416,8 @@
  	noProxyEnv.reset()
 
 === modified file 'http13client/header_test.go'
---- http13client/header_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/header_test.go	2014-03-19 22:27:37 +0000
+--- http13client/header_test.go	2014-06-20 11:00:47 +0000
++++ http13client/header_test.go	2014-06-20 12:00:22 +0000
 @@ -6,19 +6,20 @@
  
  import (
@@ -731,8 +548,8 @@
  	}
 
 === modified file 'http13client/npn_test.go'
---- http13client/npn_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/npn_test.go	2014-03-19 22:27:37 +0000
+--- http13client/npn_test.go	2014-06-20 11:00:47 +0000
++++ http13client/npn_test.go	2014-06-20 12:05:53 +0000
 @@ -11,13 +11,14 @@
  	"io"
  	"io/ioutil"
@@ -792,8 +609,8 @@
  func (w http09Writer) WriteHeader(int) {} // no headers
 
 === modified file 'http13client/readrequest_test.go'
---- http13client/readrequest_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/readrequest_test.go	2014-03-19 22:27:37 +0000
+--- http13client/readrequest_test.go	2014-06-20 11:00:47 +0000
++++ http13client/readrequest_test.go	2014-06-20 12:00:22 +0000
 @@ -9,6 +9,7 @@
  	"bytes"
  	"fmt"
@@ -909,8 +726,8 @@
  			Close:         false,
 
 === modified file 'http13client/request_test.go'
---- http13client/request_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/request_test.go	2014-03-19 22:27:37 +0000
+--- http13client/request_test.go	2014-06-20 11:00:47 +0000
++++ http13client/request_test.go	2014-06-20 12:05:53 +0000
 @@ -12,6 +12,7 @@
  	"io/ioutil"
  	"mime/multipart"
@@ -945,8 +762,26 @@
 +	req.Header = http.Header{"Content-Type": {"text/plain"}}
  	multipart, err = req.MultipartReader()
  	if multipart != nil {
- 		t.Errorf("unexpected multipart for text/plain")
-@@ -159,7 +160,7 @@
+ 		t.Error("unexpected multipart for text/plain")
+@@ -161,7 +162,7 @@
+ func TestParseMultipartForm(t *testing.T) {
+ 	req := &Request{
+ 		Method: "POST",
+-		Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
++		Header: http.Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
+ 		Body:   ioutil.NopCloser(new(bytes.Buffer)),
+ 	}
+ 	err := req.ParseMultipartForm(25)
+@@ -169,7 +170,7 @@
+ 		t.Error("expected multipart EOF, got nil")
+ 	}
+ 
+-	req.Header = Header{"Content-Type": {"text/plain"}}
++	req.Header = http.Header{"Content-Type": {"text/plain"}}
+ 	err = req.ParseMultipartForm(25)
+ 	if err != ErrNotMultipart {
+ 		t.Error("expected ErrNotMultipart for text/plain")
+@@ -177,7 +178,7 @@
  }
  
  func TestRedirect(t *testing.T) {
@@ -957,8 +792,8 @@
  			w.Header().Set("Location", "/foo/")
 
 === modified file 'http13client/requestwrite_test.go'
---- http13client/requestwrite_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/requestwrite_test.go	2014-03-19 22:27:37 +0000
+--- http13client/requestwrite_test.go	2014-06-20 11:00:47 +0000
++++ http13client/requestwrite_test.go	2014-06-20 12:00:22 +0000
 @@ -10,6 +10,7 @@
  	"fmt"
  	"io"
@@ -1068,8 +903,8 @@
  		var braw bytes.Buffer
 
 === modified file 'http13client/response_test.go'
---- http13client/response_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/response_test.go	2014-03-19 22:27:37 +0000
+--- http13client/response_test.go	2014-06-20 11:00:47 +0000
++++ http13client/response_test.go	2014-06-20 12:05:53 +0000
 @@ -12,6 +12,7 @@
  	"fmt"
  	"io"
@@ -1078,7 +913,7 @@
  	"net/url"
  	"reflect"
  	"regexp"
-@@ -44,7 +45,7 @@
+@@ -48,7 +49,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 0,
  			Request:    dummyReq("GET"),
@@ -1087,7 +922,7 @@
  				"Connection": {"close"}, // TODO(rsc): Delete?
  			},
  			Close:         true,
-@@ -67,7 +68,7 @@
+@@ -71,7 +72,7 @@
  			Proto:         "HTTP/1.1",
  			ProtoMajor:    1,
  			ProtoMinor:    1,
@@ -1096,7 +931,7 @@
  			Request:       dummyReq("GET"),
  			Close:         true,
  			ContentLength: -1,
-@@ -88,7 +89,7 @@
+@@ -92,7 +93,7 @@
  			Proto:         "HTTP/1.1",
  			ProtoMajor:    1,
  			ProtoMinor:    1,
@@ -1105,7 +940,7 @@
  			Request:       dummyReq("GET"),
  			Close:         false,
  			ContentLength: 0,
-@@ -112,7 +113,7 @@
+@@ -116,7 +117,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 0,
  			Request:    dummyReq("GET"),
@@ -1114,61 +949,61 @@
  				"Connection":     {"close"},
  				"Content-Length": {"10"},
  			},
-@@ -142,7 +143,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("GET"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			Close:            false,
- 			ContentLength:    -1,
- 			TransferEncoding: []string{"chunked"},
-@@ -169,7 +170,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("GET"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			Close:            false,
- 			ContentLength:    -1,
- 			TransferEncoding: []string{"chunked"},
-@@ -191,7 +192,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			TransferEncoding: []string{"chunked"},
- 			Close:            false,
- 			ContentLength:    -1,
-@@ -213,7 +214,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       0,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{"Content-Length": {"256"}},
-+			Header:           http.Header{"Content-Length": {"256"}},
- 			TransferEncoding: nil,
- 			Close:            true,
- 			ContentLength:    256,
-@@ -235,7 +236,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       1,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{"Content-Length": {"256"}},
-+			Header:           http.Header{"Content-Length": {"256"}},
- 			TransferEncoding: nil,
- 			Close:            false,
- 			ContentLength:    256,
-@@ -256,7 +257,7 @@
- 			ProtoMajor:       1,
- 			ProtoMinor:       0,
- 			Request:          dummyReq("HEAD"),
--			Header:           Header{},
-+			Header:           http.Header{},
- 			TransferEncoding: nil,
- 			Close:            true,
- 			ContentLength:    -1,
-@@ -278,7 +279,7 @@
+@@ -146,7 +147,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("GET"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			Close:            false,
+ 			ContentLength:    -1,
+ 			TransferEncoding: []string{"chunked"},
+@@ -173,7 +174,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("GET"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			Close:            false,
+ 			ContentLength:    -1,
+ 			TransferEncoding: []string{"chunked"},
+@@ -195,7 +196,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			TransferEncoding: []string{"chunked"},
+ 			Close:            false,
+ 			ContentLength:    -1,
+@@ -217,7 +218,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       0,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{"Content-Length": {"256"}},
++			Header:           http.Header{"Content-Length": {"256"}},
+ 			TransferEncoding: nil,
+ 			Close:            true,
+ 			ContentLength:    256,
+@@ -239,7 +240,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       1,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{"Content-Length": {"256"}},
++			Header:           http.Header{"Content-Length": {"256"}},
+ 			TransferEncoding: nil,
+ 			Close:            false,
+ 			ContentLength:    256,
+@@ -260,7 +261,7 @@
+ 			ProtoMajor:       1,
+ 			ProtoMinor:       0,
+ 			Request:          dummyReq("HEAD"),
+-			Header:           Header{},
++			Header:           http.Header{},
+ 			TransferEncoding: nil,
+ 			Close:            true,
+ 			ContentLength:    -1,
+@@ -282,7 +283,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 1,
  			Request:    dummyReq("GET"),
@@ -1177,25 +1012,25 @@
  				"Content-Length": {"0"},
  			},
  			Close:         false,
-@@ -299,7 +300,7 @@
- 			ProtoMajor:    1,
- 			ProtoMinor:    0,
- 			Request:       dummyReq("GET"),
--			Header:        Header{},
-+			Header:        http.Header{},
- 			Close:         true,
- 			ContentLength: -1,
- 		},
-@@ -318,7 +319,7 @@
- 			ProtoMajor:    1,
- 			ProtoMinor:    0,
- 			Request:       dummyReq("GET"),
--			Header:        Header{},
-+			Header:        http.Header{},
- 			Close:         true,
- 			ContentLength: -1,
- 		},
-@@ -340,7 +341,7 @@
+@@ -303,7 +304,7 @@
+ 			ProtoMajor:    1,
+ 			ProtoMinor:    0,
+ 			Request:       dummyReq("GET"),
+-			Header:        Header{},
++			Header:        http.Header{},
+ 			Close:         true,
+ 			ContentLength: -1,
+ 		},
+@@ -322,7 +323,7 @@
+ 			ProtoMajor:    1,
+ 			ProtoMinor:    0,
+ 			Request:       dummyReq("GET"),
+-			Header:        Header{},
++			Header:        http.Header{},
+ 			Close:         true,
+ 			ContentLength: -1,
+ 		},
+@@ -344,7 +345,7 @@
  			ProtoMajor: 1,
  			ProtoMinor: 1,
  			Request:    dummyReq("GET"),
@@ -1204,7 +1039,7 @@
  				"Content-Type": []string{"multipart/byteranges; boundary=18a75608c8f47cef"},
  			},
  			Close:         true,
-@@ -363,7 +364,7 @@
+@@ -367,7 +368,7 @@
  			Proto:      "HTTP/1.0",
  			ProtoMajor: 1,
  			ProtoMinor: 0,
@@ -1213,7 +1048,7 @@
  				"Connection": {"close"}, // TODO(rsc): Delete?
  			},
  			Close:         true,
-@@ -545,7 +546,7 @@
+@@ -549,7 +550,7 @@
  func TestLocationResponse(t *testing.T) {
  	for i, tt := range responseLocationTests {
  		res := new(Response)
@@ -1222,7 +1057,7 @@
  		res.Header.Set("Location", tt.location)
  		if tt.requrl != "" {
  			res.Request = &Request{}
-@@ -626,16 +627,3 @@
+@@ -630,16 +631,3 @@
  		t.Errorf("ReadResponse = %v; want io.ErrUnexpectedEOF", err)
  	}
  }
@@ -1241,8 +1076,8 @@
 -}
 
 === modified file 'http13client/responsewrite_test.go'
---- http13client/responsewrite_test.go	2014-03-19 20:20:19 +0000
-+++ http13client/responsewrite_test.go	2014-03-19 22:27:37 +0000
+--- http13client/responsewrite_test.go	2014-06-20 11:00:47 +0000
++++ http13client/responsewrite_test.go	2014-06-20 12:05:53 +0000
 @@ -7,6 +7,7 @@
  import (
  	"bytes"
@@ -1257,7 +1092,7 @@
  				Request:       dummyReq("GET"),
 -				Header:        Header{},
 +				Header:        http.Header{},
- 				Body:          ioutil.NopCloser(bytes.NewBufferString("abcdef")),
+ 				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
  				ContentLength: 6,
  			},
 @@ -41,7 +42,7 @@
@@ -1270,6 +1105,60 @@
  				ContentLength: -1,
  			},
 @@ -56,7 +57,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
+ 				ContentLength: -1,
+ 				Close:         true,
+@@ -73,7 +74,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("abcdef")),
+ 				ContentLength: -1,
+ 				Close:         false,
+@@ -91,7 +92,7 @@
+ 				ProtoMajor:       1,
+ 				ProtoMinor:       1,
+ 				Request:          dummyReq11("GET"),
+-				Header:           Header{},
++				Header:           http.Header{},
+ 				Body:             ioutil.NopCloser(strings.NewReader("abcdef")),
+ 				ContentLength:    -1,
+ 				TransferEncoding: []string{"chunked"},
+@@ -108,7 +109,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          nil,
+ 				ContentLength: 0,
+ 				Close:         false,
+@@ -124,7 +125,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("")),
+ 				ContentLength: 0,
+ 				Close:         false,
+@@ -140,7 +141,7 @@
+ 				ProtoMajor:    1,
+ 				ProtoMinor:    1,
+ 				Request:       dummyReq11("GET"),
+-				Header:        Header{},
++				Header:        http.Header{},
+ 				Body:          ioutil.NopCloser(strings.NewReader("foo")),
+ 				ContentLength: 0,
+ 				Close:         false,
+@@ -156,7 +157,7 @@
  				ProtoMajor:       1,
  				ProtoMinor:       1,
  				Request:          dummyReq("GET"),
@@ -1278,7 +1167,7 @@
  				Body:             ioutil.NopCloser(strings.NewReader("abcdef")),
  				ContentLength:    6,
  				TransferEncoding: []string{"chunked"},
-@@ -77,7 +78,7 @@
+@@ -177,7 +178,7 @@
  				ProtoMajor: 1,
  				ProtoMinor: 1,
  				Request:    dummyReq("GET"),
@@ -1287,11 +1176,20 @@
  					"Foo": []string{" Bar\nBaz "},
  				},
  				Body:             nil,
+@@ -200,7 +201,7 @@
+ 				ProtoMajor:       1,
+ 				ProtoMinor:       1,
+ 				Request:          &Request{Method: "POST"},
+-				Header:           Header{},
++				Header:           http.Header{},
+ 				ContentLength:    0,
+ 				TransferEncoding: nil,
+ 				Body:             nil,
 
 === modified file 'http13client/transport_test.go'
---- http13client/transport_test.go	2014-03-19 21:38:56 +0000
-+++ http13client/transport_test.go	2014-03-19 22:27:37 +0000
-@@ -17,8 +17,8 @@
+--- http13client/transport_test.go	2014-06-20 11:00:47 +0000
++++ http13client/transport_test.go	2014-06-20 12:05:53 +0000
+@@ -18,8 +18,8 @@
  	"io/ioutil"
  	"log"
  	"net"
@@ -1301,7 +1199,7 @@
  	"net/http/httptest"
  	"net/url"
  	"os"
-@@ -34,7 +34,7 @@
+@@ -35,7 +35,7 @@
  //       and then verify that the final 2 responses get errors back.
  
  // hostPortHandler writes back the client's "host:port".
@@ -1310,7 +1208,7 @@
  	if r.FormValue("close") == "true" {
  		w.Header().Set("Connection", "close")
  	}
-@@ -280,7 +280,7 @@
+@@ -289,7 +289,7 @@
  	const msg = "foobar"
  
  	var addrSeen map[string]int
@@ -1319,7 +1217,7 @@
  		addrSeen[r.RemoteAddr]++
  		if r.URL.Path == "/chunked/" {
  			w.WriteHeader(200)
-@@ -299,7 +299,7 @@
+@@ -308,7 +308,7 @@
  		wantLen := []int{len(msg), -1}[pi]
  		addrSeen = make(map[string]int)
  		for i := 0; i < 3; i++ {
@@ -1328,7 +1226,7 @@
  			if err != nil {
  				t.Errorf("Get %s: %v", path, err)
  				continue
-@@ -329,7 +329,7 @@
+@@ -338,7 +338,7 @@
  	defer afterTest(t)
  	resch := make(chan string)
  	gotReq := make(chan bool)
@@ -1337,7 +1235,7 @@
  		gotReq <- true
  		msg := <-resch
  		_, err := w.Write([]byte(msg))
-@@ -457,12 +457,12 @@
+@@ -466,12 +466,12 @@
  	if testing.Short() {
  		t.Skip("skipping test in short mode")
  	}
@@ -1353,7 +1251,7 @@
  		buf.Flush()
  		conn.Close()
  	}))
-@@ -510,7 +510,7 @@
+@@ -519,7 +519,7 @@
  // with no bodies properly
  func TestTransportHeadResponses(t *testing.T) {
  	defer afterTest(t)
@@ -1362,7 +1260,7 @@
  		if r.Method != "HEAD" {
  			panic("expected HEAD; got " + r.Method)
  		}
-@@ -545,7 +545,7 @@
+@@ -554,7 +554,7 @@
  // on responses to HEAD requests.
  func TestTransportHeadChunkedResponse(t *testing.T) {
  	defer afterTest(t)
@@ -1371,7 +1269,7 @@
  		if r.Method != "HEAD" {
  			panic("expected HEAD; got " + r.Method)
  		}
-@@ -588,7 +588,7 @@
+@@ -597,7 +597,7 @@
  func TestRoundTripGzip(t *testing.T) {
  	defer afterTest(t)
  	const responseBody = "test response body"
@@ -1380,7 +1278,7 @@
  		accept := req.Header.Get("Accept-Encoding")
  		if expect := req.FormValue("expect_accept"); accept != expect {
  			t.Errorf("in handler, test %v: Accept-Encoding = %q, want %q",
-@@ -647,7 +647,7 @@
+@@ -656,7 +656,7 @@
  	defer afterTest(t)
  	const testString = "The test string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  	const nRandBytes = 1024 * 1024
@@ -1389,7 +1287,7 @@
  		if req.Method == "HEAD" {
  			if g := req.Header.Get("Accept-Encoding"); g != "" {
  				t.Errorf("HEAD request sent with Accept-Encoding of %q; want none", g)
-@@ -742,11 +742,11 @@
+@@ -751,11 +751,11 @@
  func TestTransportProxy(t *testing.T) {
  	defer afterTest(t)
  	ch := make(chan string, 1)
@@ -1403,7 +1301,7 @@
  		ch <- "proxy for " + r.URL.String()
  	}))
  	defer proxy.Close()
-@@ -770,7 +770,7 @@
+@@ -779,7 +779,7 @@
  // Content-Encoding is removed.
  func TestTransportGzipRecursive(t *testing.T) {
  	defer afterTest(t)
@@ -1412,7 +1310,16 @@
  		w.Header().Set("Content-Encoding", "gzip")
  		w.Write(rgz)
  	}))
-@@ -802,7 +802,7 @@
+@@ -807,7 +807,7 @@
+ // a short gzip body
+ func TestTransportGzipShort(t *testing.T) {
+ 	defer afterTest(t)
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		w.Header().Set("Content-Encoding", "gzip")
+ 		w.Write([]byte{0x1f, 0x8b})
+ 	}))
+@@ -838,7 +838,7 @@
  	defer afterTest(t)
  	gotReqCh := make(chan bool)
  	unblockCh := make(chan bool)
@@ -1421,7 +1328,7 @@
  		gotReqCh <- true
  		<-unblockCh
  		w.Header().Set("Content-Length", "0")
-@@ -869,7 +869,7 @@
+@@ -905,7 +905,7 @@
  		t.Skip("skipping test; see http://golang.org/issue/7237")
  	}
  	defer afterTest(t)
@@ -1430,7 +1337,7 @@
  	}))
  	defer ts.Close()
  
-@@ -912,7 +912,7 @@
+@@ -948,7 +948,7 @@
  	c := &Client{Transport: tr}
  
  	unblockCh := make(chan bool, 1)
@@ -1439,7 +1346,7 @@
  		<-unblockCh
  		tr.CloseIdleConnections()
  	}))
-@@ -939,7 +939,7 @@
+@@ -975,7 +975,7 @@
  func TestIssue3644(t *testing.T) {
  	defer afterTest(t)
  	const numFoos = 5000
@@ -1448,7 +1355,7 @@
  		w.Header().Set("Connection", "close")
  		for i := 0; i < numFoos; i++ {
  			w.Write([]byte("foo "))
-@@ -967,8 +967,8 @@
+@@ -1003,8 +1003,8 @@
  func TestIssue3595(t *testing.T) {
  	defer afterTest(t)
  	const deniedMsg = "sorry, denied."
@@ -1459,7 +1366,7 @@
  	}))
  	defer ts.Close()
  	tr := &Transport{}
-@@ -991,7 +991,7 @@
+@@ -1027,7 +1027,7 @@
  // "client fails to handle requests with no body and chunked encoding"
  func TestChunkedNoContent(t *testing.T) {
  	defer afterTest(t)
@@ -1468,7 +1375,7 @@
  		w.WriteHeader(StatusNoContent)
  	}))
  	defer ts.Close()
-@@ -1019,7 +1019,7 @@
+@@ -1055,7 +1055,7 @@
  		maxProcs, numReqs = 4, 50
  	}
  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(maxProcs))
@@ -1477,7 +1384,7 @@
  		fmt.Fprintf(w, "%v", r.FormValue("echo"))
  	}))
  	defer ts.Close()
-@@ -1080,8 +1080,8 @@
+@@ -1116,8 +1116,8 @@
  	}
  	defer afterTest(t)
  	const debug = false
@@ -1488,7 +1395,7 @@
  		io.Copy(w, neverEnding('a'))
  	})
  	ts := httptest.NewServer(mux)
-@@ -1144,11 +1144,11 @@
+@@ -1180,11 +1180,11 @@
  	}
  	defer afterTest(t)
  	const debug = false
@@ -1503,20 +1410,22 @@
  		defer r.Body.Close()
  		io.Copy(ioutil.Discard, r.Body)
  	})
-@@ -1214,9 +1214,9 @@
- 	if testing.Short() {
+@@ -1251,11 +1251,11 @@
  		t.Skip("skipping timeout test in -short mode")
  	}
+ 	inHandler := make(chan bool, 1)
 -	mux := NewServeMux()
--	mux.HandleFunc("/fast", func(w ResponseWriter, r *Request) {})
+-	mux.HandleFunc("/fast", func(w ResponseWriter, r *Request) {
++	mux := http.NewServeMux()
++	mux.HandleFunc("/fast", func(w http.ResponseWriter, r *http.Request) {
+ 		inHandler <- true
+ 	})
 -	mux.HandleFunc("/slow", func(w ResponseWriter, r *Request) {
-+	mux := http.NewServeMux()
-+	mux.HandleFunc("/fast", func(w http.ResponseWriter, r *http.Request) {})
 +	mux.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) {
+ 		inHandler <- true
  		time.Sleep(2 * time.Second)
  	})
- 	ts := httptest.NewServer(mux)
-@@ -1276,9 +1276,9 @@
+@@ -1322,9 +1322,9 @@
  		t.Skip("skipping test in -short mode")
  	}
  	unblockc := make(chan bool)
@@ -1528,7 +1437,7 @@
  		<-unblockc
  	}))
  	defer ts.Close()
-@@ -1386,14 +1386,14 @@
+@@ -1431,14 +1431,14 @@
  	defer afterTest(t)
  	writeErr := make(chan error, 1)
  	msg := []byte("young\n")
@@ -1545,7 +1454,7 @@
  		}
  	}))
  	defer ts.Close()
-@@ -1449,7 +1449,7 @@
+@@ -1494,7 +1494,7 @@
  	res := &Response{
  		Status:     "200 OK",
  		StatusCode: 200,
@@ -1554,7 +1463,7 @@
  		Body:       ioutil.NopCloser(strings.NewReader("You wanted " + req.URL.String())),
  	}
  	return res, nil
-@@ -1478,7 +1478,7 @@
+@@ -1523,7 +1523,7 @@
  	defer afterTest(t)
  	tr := &Transport{}
  	_, err := tr.RoundTrip(&Request{
@@ -1563,7 +1472,7 @@
  		URL: &url.URL{
  			Scheme: "http",
  		},
-@@ -1492,14 +1492,14 @@
+@@ -1537,14 +1537,14 @@
  func TestTransportSocketLateBinding(t *testing.T) {
  	defer afterTest(t)
  
@@ -1582,7 +1491,7 @@
  		w.Header().Set("bar-ipport", r.RemoteAddr)
  	})
  	ts := httptest.NewServer(mux)
-@@ -1720,7 +1720,7 @@
+@@ -1767,7 +1767,7 @@
  	var mu sync.Mutex
  	var n int
  
@@ -1591,7 +1500,7 @@
  		mu.Lock()
  		n++
  		mu.Unlock()
-@@ -1756,7 +1756,7 @@
+@@ -1803,7 +1803,7 @@
  // then closes it.
  func TestTransportClosesRequestBody(t *testing.T) {
  	defer afterTest(t)
@@ -1600,4 +1509,49 @@
  		io.Copy(ioutil.Discard, r.Body)
  	}))
  	defer ts.Close()
+@@ -1890,9 +1890,9 @@
+ 		t.Skip("skipping flaky test on Windows; golang.org/issue/7634")
+ 	}
+ 	closedc := make(chan bool, 1)
+-	ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		if strings.Contains(r.URL.Path, "/keep-alive-then-die") {
+-			conn, _, _ := w.(Hijacker).Hijack()
++			conn, _, _ := w.(http.Hijacker).Hijack()
+ 			conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nfoo"))
+ 			conn.Close()
+ 			closedc <- true
+@@ -1994,12 +1994,12 @@
+ 	}
+ 	defer closeConn()
+ 
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		if r.Method == "GET" {
+ 			io.WriteString(w, "bar")
+ 			return
+ 		}
+-		conn, _, _ := w.(Hijacker).Hijack()
++		conn, _, _ := w.(http.Hijacker).Hijack()
+ 		sconn.Lock()
+ 		sconn.c = conn
+ 		sconn.Unlock()
+@@ -2056,7 +2056,7 @@
+ 	}
+ 	defer afterTest(t)
+ 	readBody := make(chan error, 1)
+-	ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
++	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ 		_, err := ioutil.ReadAll(r.Body)
+ 		readBody <- err
+ 	}))
+@@ -2098,7 +2098,7 @@
+ 	}
+ }
+ 
+-func wantBody(res *http.Response, err error, want string) error {
++func wantBody(res *Response, err error, want string) error {
+ 	if err != nil {
+ 		return err
+ 	}
 
 
=== modified file 'http13client/_using.txt'
--- http13client/_using.txt	2014-03-20 12:20:01 +0000
+++ http13client/_using.txt	2014-07-02 13:12:36 +0000
@@ -1,5 +1,5 @@
-parent: 19512:32c32aef2a41 tip
- test: enable bug385_32 test on amd64p32.
-branch: default
+parent: 20169:9895f9e36435 go1.3 release
+ go1.3
+branch: release-branch.go1.3
 commit: (clean)
 update: (current)
 
=== modified file 'http13client/client.go'
--- http13client/client.go	2014-03-20 09:26:28 +0000
+++ http13client/client.go	2014-07-02 13:12:36 +0000
@@ -92,8 +92,9 @@
 	// authentication, or cookies.
 	//
 	// RoundTrip should not modify the request, except for
-	// consuming and closing the Body. The request's URL and
-	// Header fields are guaranteed to be initialized.
+	// consuming and closing the Body, including on errors. The
+	// request's URL and Header fields are guaranteed to be
+	// initialized.
 	RoundTrip(*Request) (*Response, error)
 }
 
@@ -141,6 +142,9 @@
 // (typically Transport) may not be able to re-use a persistent TCP
 // connection to the server for a subsequent "keep-alive" request.
 //
+// The request Body, if non-nil, will be closed by the underlying
+// Transport, even on errors.
+//
 // Generally Get, Post, or PostForm will be used instead of Do.
 func (c *Client) Do(req *Request) (resp *Response, err error) {
 	if req.Method == "GET" || req.Method == "HEAD" {
@@ -163,14 +167,17 @@
 // Caller should close resp.Body when done reading from it.
 func send(req *Request, t RoundTripper) (resp *Response, err error) {
 	if t == nil {
+		req.closeBody()
 		return nil, errors.New("http: no Client.Transport or DefaultTransport")
 	}
 
 	if req.URL == nil {
+		req.closeBody()
 		return nil, errors.New("http: nil Request.URL")
 	}
 
 	if req.RequestURI != "" {
+		req.closeBody()
 		return nil, errors.New("http: Request.RequestURI can't be set in client requests.")
 	}
 
@@ -278,6 +285,7 @@
 	var via []*Request
 
 	if ireq.URL == nil {
+		ireq.closeBody()
 		return nil, errors.New("http: nil Request.URL")
 	}
 
@@ -400,7 +408,7 @@
 // Caller should close resp.Body when done reading from it.
 //
 // If the provided body is also an io.Closer, it is closed after the
-// body is successfully written to the server.
+// request.
 func (c *Client) Post(url string, bodyType string, body io.Reader) (resp *Response, err error) {
 	req, err := NewRequest("POST", url, body)
 	if err != nil {
 
=== modified file 'http13client/client_test.go'
--- http13client/client_test.go	2014-03-20 09:26:28 +0000
+++ http13client/client_test.go	2014-07-02 13:12:36 +0000
@@ -20,6 +20,8 @@
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -877,3 +879,93 @@
 		t.Fatal("server saw different client ports before & after the redirect")
 	}
 }
+
+// eofReaderFunc is an io.Reader that runs itself, and then returns io.EOF.
+type eofReaderFunc func()
+
+func (f eofReaderFunc) Read(p []byte) (n int, err error) {
+	f()
+	return 0, io.EOF
+}
+
+func TestClientTrailers(t *testing.T) {
+	defer afterTest(t)
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Connection", "close")
+		w.Header().Set("Trailer", "Server-Trailer-A, Server-Trailer-B")
+		w.Header().Add("Trailer", "Server-Trailer-C")
+
+		var decl []string
+		for k := range r.Trailer {
+			decl = append(decl, k)
+		}
+		sort.Strings(decl)
+
+		slurp, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			t.Errorf("Server reading request body: %v", err)
+		}
+		if string(slurp) != "foo" {
+			t.Errorf("Server read request body %q; want foo", slurp)
+		}
+		if r.Trailer == nil {
+			io.WriteString(w, "nil Trailer")
+		} else {
+			fmt.Fprintf(w, "decl: %v, vals: %s, %s",
+				decl,
+				r.Trailer.Get("Client-Trailer-A"),
+				r.Trailer.Get("Client-Trailer-B"))
+		}
+
+		// TODO: golang.org/issue/7759: there's no way yet for
+		// the server to set trailers without hijacking, so do
+		// that for now, just to test the client.  Later, in
+		// Go 1.4, it should be implicit that any mutations
+		// to w.Header() after the initial write are the
+		// trailers to be sent, if and only if they were
+		// previously declared with w.Header().Set("Trailer",
+		// ..keys..)
+		w.(http.Flusher).Flush()
+		conn, buf, _ := w.(http.Hijacker).Hijack()
+		t := http.Header{}
+		t.Set("Server-Trailer-A", "valuea")
+		t.Set("Server-Trailer-C", "valuec") // skipping B
+		buf.WriteString("0\r\n")            // eof
+		t.Write(buf)
+		buf.WriteString("\r\n") // end of trailers
+		buf.Flush()
+		conn.Close()
+	}))
+	defer ts.Close()
+
+	var req *Request
+	req, _ = NewRequest("POST", ts.URL, io.MultiReader(
+		eofReaderFunc(func() {
+			req.Trailer["Client-Trailer-A"] = []string{"valuea"}
+		}),
+		strings.NewReader("foo"),
+		eofReaderFunc(func() {
+			req.Trailer["Client-Trailer-B"] = []string{"valueb"}
+		}),
+	))
+	req.Trailer = http.Header{
+		"Client-Trailer-A": nil, //  to be set later
+		"Client-Trailer-B": nil, //  to be set later
+	}
+	req.ContentLength = -1
+	res, err := DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := wantBody(res, err, "decl: [Client-Trailer-A Client-Trailer-B], vals: valuea, valueb"); err != nil {
+		t.Error(err)
+	}
+	want := http.Header{
+		"Server-Trailer-A": []string{"valuea"},
+		"Server-Trailer-B": nil,
+		"Server-Trailer-C": []string{"valuec"},
+	}
+	if !reflect.DeepEqual(res.Trailer, want) {
+		t.Errorf("Response trailers = %#v; want %#v", res.Trailer, want)
+	}
+}
 
=== modified file 'http13client/cookie.go'
--- http13client/cookie.go	2014-03-19 23:13:58 +0000
+++ http13client/cookie.go	2014-07-02 13:12:36 +0000
@@ -55,11 +55,7 @@
 				attr, val = attr[:j], attr[j+1:]
 			}
 			lowerAttr := strings.ToLower(attr)
-			parseCookieValueFn := parseCookieValue
-			if lowerAttr == "expires" {
-				parseCookieValueFn = parseCookieExpiresValue
-			}
-			val, success = parseCookieValueFn(val)
+			val, success = parseCookieValue(val)
 			if !success {
 				c.Unparsed = append(c.Unparsed, parts[i])
 				continue
@@ -230,12 +226,23 @@
 //           ; US-ASCII characters excluding CTLs,
 //           ; whitespace DQUOTE, comma, semicolon,
 //           ; and backslash
+// We loosen this as spaces and commas are common in cookie values
+// but we produce a quoted cookie-value in when value starts or ends
+// with a comma or space.
+// See http://golang.org/issue/7243 for the discussion.
 func sanitizeCookieValue(v string) string {
-	return sanitizeOrWarn("Cookie.Value", validCookieValueByte, v)
+	v = sanitizeOrWarn("Cookie.Value", validCookieValueByte, v)
+	if len(v) == 0 {
+		return v
+	}
+	if v[0] == ' ' || v[0] == ',' || v[len(v)-1] == ' ' || v[len(v)-1] == ',' {
+		return `"` + v + `"`
+	}
+	return v
 }
 
 func validCookieValueByte(b byte) bool {
-	return 0x20 < b && b < 0x7f && b != '"' && b != ',' && b != ';' && b != '\\'
+	return 0x20 <= b && b < 0x7f && b != '"' && b != ';' && b != '\\'
 }
 
 // path-av           = "Path=" path-value
@@ -270,38 +277,13 @@
 	return string(buf)
 }
 
-func unquoteCookieValue(v string) string {
-	if len(v) > 1 && v[0] == '"' && v[len(v)-1] == '"' {
-		return v[1 : len(v)-1]
-	}
-	return v
-}
-
-func isCookieByte(c byte) bool {
-	switch {
-	case c == 0x21, 0x23 <= c && c <= 0x2b, 0x2d <= c && c <= 0x3a,
-		0x3c <= c && c <= 0x5b, 0x5d <= c && c <= 0x7e:
-		return true
-	}
-	return false
-}
-
-func isCookieExpiresByte(c byte) (ok bool) {
-	return isCookieByte(c) || c == ',' || c == ' '
-}
-
 func parseCookieValue(raw string) (string, bool) {
-	return parseCookieValueUsing(raw, isCookieByte)
-}
-
-func parseCookieExpiresValue(raw string) (string, bool) {
-	return parseCookieValueUsing(raw, isCookieExpiresByte)
-}
-
-func parseCookieValueUsing(raw string, validByte func(byte) bool) (string, bool) {
-	raw = unquoteCookieValue(raw)
+	// Strip the quotes, if present.
+	if len(raw) > 1 && raw[0] == '"' && raw[len(raw)-1] == '"' {
+		raw = raw[1 : len(raw)-1]
+	}
 	for i := 0; i < len(raw); i++ {
-		if !validByte(raw[i]) {
+		if !validCookieValueByte(raw[i]) {
 			return "", false
 		}
 	}
 
=== removed file 'http13client/cookie_test.go'
--- http13client/cookie_test.go	2014-03-19 23:13:58 +0000
+++ http13client/cookie_test.go	1970-01-01 00:00:00 +0000
@@ -1,304 +0,0 @@
-// Copyright 2010 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package http
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-)
-
-var writeSetCookiesTests = []struct {
-	Cookie *http.Cookie
-	Raw    string
-}{
-	{
-		&http.Cookie{Name: "cookie-1", Value: "v$1"},
-		"cookie-1=v$1",
-	},
-	{
-		&http.Cookie{Name: "cookie-2", Value: "two", MaxAge: 3600},
-		"cookie-2=two; Max-Age=3600",
-	},
-	{
-		&http.Cookie{Name: "cookie-3", Value: "three", Domain: ".example.com"},
-		"cookie-3=three; Domain=example.com",
-	},
-	{
-		&http.Cookie{Name: "cookie-4", Value: "four", Path: "/restricted/"},
-		"cookie-4=four; Path=/restricted/",
-	},
-	{
-		&http.Cookie{Name: "cookie-5", Value: "five", Domain: "wrong;bad.abc"},
-		"cookie-5=five",
-	},
-	{
-		&http.Cookie{Name: "cookie-6", Value: "six", Domain: "bad-.abc"},
-		"cookie-6=six",
-	},
-	{
-		&http.Cookie{Name: "cookie-7", Value: "seven", Domain: "127.0.0.1"},
-		"cookie-7=seven; Domain=127.0.0.1",
-	},
-	{
-		&http.Cookie{Name: "cookie-8", Value: "eight", Domain: "::1"},
-		"cookie-8=eight",